graphing: leave a combined graph's axis to auto-scale over several objects

A range bound that is a quantity names one object's thresholds, so over
several matched ones it resolved against whichever came first. Drop it
and keep only the numeric ends, as the legacy combined path does.

CMK-37904

Change-Id: Ib2ab00b0a953a2a2e4f3c1486b5a2b497c61fbc5
JIRA-Ref: CMK-37904

Author: ottermata

packages/cmk-graphing-engine/cmk/graphing_engine/_api_plugins.py

@@ -68,7 +68,7 @@ def is_scalar(quantity: ApiQuantity) -> bool:
             assert_never(quantity)
 
 
-def _metric_names_in_quantity(quantity: ApiQuantity) -> Iterable[MetricName]:
+def metric_names_in_quantity(quantity: ApiQuantity) -> Iterable[MetricName]:
     match quantity:
         case str():
             yield MetricName(quantity)
@@ -90,7 +90,7 @@ def _metric_names_in_quantity(quantity: ApiQuantity) -> Iterable[MetricName]:
             | metrics_v1.Fraction()
         ):
             for operand in operands_of(quantity):
-                yield from _metric_names_in_quantity(operand)
+                yield from metric_names_in_quantity(operand)
         case _:
             assert_never(quantity)
 
@@ -103,6 +103,6 @@ def drawn_metric_names_of_graph(
             name
             for quantity in (*graph.compound_lines, *graph.simple_lines)
             if not is_scalar(quantity)
-            for name in _metric_names_in_quantity(quantity)
+            for name in metric_names_in_quantity(quantity)
         }
     )

packages/cmk-graphing-engine/cmk/graphing_engine/_from_api.py

@@ -12,7 +12,7 @@
 from cmk.graphing.v2_unstable import graphs as graphs_v2_unstable
 from cmk.graphing.v2_unstable import metrics as metrics_v2_unstable
 
-from ._api_plugins import ApiQuantity, is_scalar, operands_of
+from ._api_plugins import ApiQuantity, is_scalar, metric_names_in_quantity, operands_of
 from ._display import (
     FALLBACK_ATTRIBUTES,
     metric_display_attributes,
@@ -171,9 +171,13 @@ def _parse_quantity(quantity: ApiQuantity, context: _ParseContext) -> QuantityPr
             assert_never(quantity)
 
 
-def _parse_bound(bound: int | float | ApiQuantity, context: _ParseContext) -> Bound:
+def _parse_bound(bound: int | float | ApiQuantity, context: _ParseContext) -> Bound | None:
     if isinstance(bound, int | float):
         return bound
+    # A bound naming a metric is read from one object; over several matched ones there is none, so
+    # that end is left to auto-scale. A bound of constants alone is read without one.
+    if len(context.services) > 1 and any(metric_names_in_quantity(bound)):
+        return None
     return _parse_quantity(bound, context)
 
 
@@ -183,10 +187,11 @@ def _parse_range(
 ) -> MinimalRange | None:
     if graph.minimal_range is None:
         return None
-    return MinimalRange(
-        lower=_parse_bound(graph.minimal_range.lower, context),
-        upper=_parse_bound(graph.minimal_range.upper, context),
-    )
+    lower = _parse_bound(graph.minimal_range.lower, context)
+    upper = _parse_bound(graph.minimal_range.upper, context)
+    if lower is None and upper is None:
+        return None
+    return MinimalRange(lower=lower, upper=upper)
 
 
 def _widest_bound(
@@ -196,7 +201,8 @@ def _widest_bound(
 ) -> Bound | None:
     if isinstance(of_upper, int | float) and isinstance(of_lower, int | float):
         return pick(of_upper, of_lower)
-    # Two quantity bounds cannot be compared before they are evaluated, so the upper half's wins.
+    # Two quantity bounds cannot be compared before they are evaluated, so the upper half's wins; a
+    # half whose end was dropped has none, and then the other half's end is the range.
     return of_lower if of_upper is None else of_upper
 
 

packages/cmk-graphing-engine/tests/test_matching.py

@@ -14,6 +14,7 @@
     build_curve,
     build_matched_graphs,
     ConsolidationFunction,
+    Constant,
     evaluate_graphs,
     EvaluatedGraph,
     FetchedData,
@@ -22,6 +23,7 @@
     Line,
     MetricName,
     MetricProtocol,
+    MinimalRange,
     parse_graph_from_api,
     PerformanceData,
     QuantityProtocol,
@@ -761,3 +763,140 @@ def test_build_matched_graphs_matches_via_a_service_without_the_conflicting_metr
 
     # h2 carries the conflicting metric, but h1 does not, so the plugin still matches via h1.
     assert "cpu" in {d.name for d in discovered}
+
+
+def _graph_with_a_quantity_bound() -> graphs_v1.Graph:
+    return graphs_v1.Graph(
+        name="cpu",
+        title=Title("CPU"),
+        minimal_range=graphs_v1.MinimalRange(
+            0, metrics_v1.MaximumOf("cpu_user", metrics_v1.Color.GREEN)
+        ),
+        simple_lines=["cpu_user"],
+    )
+
+
+def test_build_matched_graphs_keeps_a_quantity_range_bound_for_one_service() -> None:
+    service = _service()
+    cpu_user = MetricName("cpu_user")
+    fetch_data = _FakeRRDFetchData(
+        performance_response={service: _perf_data(_perf(cpu_user, maximum=100.0))}
+    )
+
+    [discovered] = _discover([_graph_with_a_quantity_bound()], fetch_data=fetch_data)
+
+    assert discovered.vertical_range is not None
+    assert discovered.vertical_range.lower == 0
+    upper = discovered.vertical_range.upper
+    assert isinstance(upper, ScalarOf)
+    assert upper.metric == _rrd(cpu_user)
+    assert upper.scalar_kind is ScalarKind.MAXIMUM
+
+
+def test_build_matched_graphs_drops_a_quantity_range_bound_for_multiple_services() -> None:
+    h1, h2 = _services()
+    cpu_user = MetricName("cpu_user")
+    fetch_data = _FakeRRDFetchData(
+        performance_response={
+            h1: _perf_data(_perf(cpu_user, maximum=100.0)),
+            h2: _perf_data(_perf(cpu_user, maximum=200.0)),
+        }
+    )
+
+    [discovered] = _discover_combined([_graph_with_a_quantity_bound()], fetch_data=fetch_data)
+
+    # The numeric end is kept; the threshold end belongs to no one matched object, so it is dropped
+    # rather than resolved against an arbitrary one.
+    assert discovered.vertical_range == MinimalRange(lower=0, upper=None)
+
+
+def test_build_matched_graphs_drops_a_wholly_quantity_range_for_multiple_services() -> None:
+    h1, h2 = _services()
+    cpu_user = MetricName("cpu_user")
+    plugin = graphs_v1.Graph(
+        name="cpu",
+        title=Title("CPU"),
+        minimal_range=graphs_v1.MinimalRange(
+            metrics_v1.MinimumOf("cpu_user", metrics_v1.Color.GREEN),
+            metrics_v1.MaximumOf("cpu_user", metrics_v1.Color.GREEN),
+        ),
+        simple_lines=["cpu_user"],
+    )
+    fetch_data = _FakeRRDFetchData(
+        performance_response={
+            h1: _perf_data(_perf(cpu_user, minimum=0.0, maximum=100.0)),
+            h2: _perf_data(_perf(cpu_user, minimum=0.0, maximum=200.0)),
+        }
+    )
+
+    [discovered] = _discover_combined([plugin], fetch_data=fetch_data)
+
+    # Neither end survives, so there is no range rather than one holding nothing.
+    assert discovered.vertical_range is None
+
+
+def test_build_matched_graphs_keeps_a_constant_range_bound_for_multiple_services() -> None:
+    h1, h2 = _services()
+    cpu_user = MetricName("cpu_user")
+    plugin = graphs_v1.Graph(
+        name="cpu",
+        title=Title("CPU"),
+        minimal_range=graphs_v1.MinimalRange(
+            0,
+            metrics_v1.Constant(
+                Title("Ceiling"),
+                metrics_v1.Unit(metrics_v1.DecimalNotation("")),
+                metrics_v1.Color.GRAY,
+                100.0,
+            ),
+        ),
+        simple_lines=["cpu_user"],
+    )
+    fetch_data = _FakeRRDFetchData(
+        performance_response={h1: _perf_data(_perf(cpu_user)), h2: _perf_data(_perf(cpu_user))}
+    )
+
+    [discovered] = _discover_combined([plugin], fetch_data=fetch_data)
+
+    # A bound of constants alone names no metric, so it needs no object and survives.
+    assert discovered.vertical_range is not None
+    assert discovered.vertical_range.lower == 0
+    upper = discovered.vertical_range.upper
+    assert isinstance(upper, Constant)
+    assert upper.value == 100.0
+
+
+def test_build_matched_graphs_lets_a_kept_end_win_over_a_dropped_one_when_bidirectional() -> None:
+    h1, h2 = _services()
+    cpu_user = MetricName("cpu_user")
+    cpu_system = MetricName("cpu_system")
+    plugin = graphs_v1.Bidirectional(
+        name="cpu",
+        title=Title("CPU"),
+        upper=graphs_v1.Graph(
+            name="upper",
+            title=Title("Upper"),
+            minimal_range=graphs_v1.MinimalRange(
+                0, metrics_v1.MaximumOf("cpu_user", metrics_v1.Color.GRAY)
+            ),
+            simple_lines=["cpu_user"],
+        ),
+        lower=graphs_v1.Graph(
+            name="lower",
+            title=Title("Lower"),
+            minimal_range=graphs_v1.MinimalRange(0, 50),
+            simple_lines=["cpu_system"],
+        ),
+    )
+    fetch_data = _FakeRRDFetchData(
+        performance_response={
+            h1: _perf_data(_perf(cpu_user, maximum=100.0), _perf(cpu_system)),
+            h2: _perf_data(_perf(cpu_user, maximum=200.0), _perf(cpu_system)),
+        }
+    )
+
+    [discovered] = _discover_combined([plugin], fetch_data=fetch_data)
+
+    # The upper half's threshold end is dropped, so the lower half's numeric end is the range - where
+    # a threshold resolved against one arbitrary object would have masked it.
+    assert discovered.vertical_range == MinimalRange(lower=0, upper=50)