def test_cpu_loads_predictive(mocker):
# make sure cpu_load check can handle predictive values
mocker.patch("cmk.base.check_api._prediction.get_levels",
return_value=(None, (2.2, 4.2, None, None)))
# TODO: don't mock this. Use the context managers.
mocker.patch("cmk.base.plugin_contexts._hostname", value="unittest")
mocker.patch("cmk.base.plugin_contexts._service_description",
value="unittest-sd")
params = {
'levels': {
'period': 'minute',
'horizon': 1,
'levels_upper': ('absolute', (2.0, 4.0))
}
}
section = Section(load=Load(0.5, 1.0, 1.5), num_cpus=4, num_threads=123)
result = set(check_cpu_load(params, section))
assert result == set((
Result(state=State.OK,
summary='15 min load: 1.50 (no reference for prediction yet)'),
Result(state=State.OK, summary='15 min load per core: 0.38 (4 cores)'),
Metric('load1', 0.5, boundaries=(0, 4.0)),
Metric('load5', 1.0, boundaries=(0, 4.0)),
Metric('load15', 1.5,
levels=(2.2, 4.2)), # those are the predicted values
))
def test_cpu_threads_max_threads():
section = Section(load=Load(0.1, 0.1, 0.1), num_cpus=4, num_threads=1234, max_threads=2468)
params: Dict[str, Any] = {}
result = set(check_cpu_threads(params, section))
assert result == {
Metric("thread_usage", 50.0),
Metric("threads", 1234.0),
Result(state=State.OK, summary="1234"),
Result(state=State.OK, summary="Usage: 50.00%"),
}
def test_metric():
metric1 = Metric('reproduction_rate', 1.0, levels=(2.4, 3.0), boundaries=(0, None))
metric2 = Metric('reproduction_rate', 2.0, levels=(2.4, 3.0), boundaries=(0, None))
assert metric1.name == 'reproduction_rate'
assert metric1.value == 1.0
assert metric1.levels == (2.4, 3.0)
assert metric1.boundaries == (0., None)
assert metric1 == metric1 # pylint: disable=comparison-with-itself
assert metric1 != metric2
def test_cpu_loads_fixed_levels(mocker):
section = Section(load=Load(0.5, 1.0, 1.5), num_cpus=4, num_threads=123)
params = {'levels': (2.0, 4.0)}
result = set(check_cpu_load(params, section))
assert result == set((
Result(state=State.OK, summary='15 min load: 1.50'),
Result(state=State.OK, summary='15 min load per core: 0.38 (4 cores)'),
Metric('load1', 0.5, boundaries=(0, 4.0)),
Metric('load5', 1.0, boundaries=(0, 4.0)),
Metric('load15', 1.5, levels=(8.0, 16.0)), # levels multiplied by num_cpus
))
def check_levels(
value: float,
*,
levels_upper: Optional[Tuple[float, float]] = None,
levels_lower: Optional[Tuple[float, float]] = None,
metric_name: Optional[str] = None,
render_func: Optional[Callable[[float], str]] = None,
label: Optional[str] = None,
boundaries: Optional[Tuple[Optional[float], Optional[float]]] = None,
notice_only: bool = False,
) -> Generator[Union[Result, Metric], None, None]:
"""Generic function for checking a value against levels.
Args:
value: The currently measured value
levels_upper: A pair of upper thresholds. If value is larger than these, the
service goes to **WARN** or **CRIT**, respecively.
levels_lower: A pair of lower thresholds. If value is smaller than these, the
service goes to **WARN** or **CRIT**, respecively.
metric_name: The name of the datasource in the RRD that corresponds to this value
or None in order not to generate a metric.
render_func: A single argument function to convert the value from float into a
human readable string.
label: The label to prepend to the output.
boundaries: Minimum and maximum to add to the metric.
notice_only: Only show up in service output if not OK (otherwise in details).
See `notice` keyword of `Result` class.
Example:
>>> result, = check_levels(
... 23.0,
... levels_upper=(12., 42.),
... label="Fridge",
... render_func=lambda v: "%.1f°" % v,
... )
>>> print(result.summary)
Fridge: 23.0° (warn/crit at 12.0°/42.0°)
"""
if render_func is None:
render_func = lambda f: "%.2f" % f
info_text = str(render_func(value)) # forgive wrong output type
if label:
info_text = "%s: %s" % (label, info_text)
value_state, levels_text = _do_check_levels(value, levels_upper,
levels_lower, render_func)
if notice_only:
yield Result(state=value_state, notice=info_text + levels_text)
else:
yield Result(state=value_state, summary=info_text + levels_text)
if metric_name:
yield Metric(metric_name,
value,
levels=levels_upper,
boundaries=boundaries)
def _create_new_result(
is_details: bool,
legacy_state: int,
legacy_text: str,
legacy_metrics: Union[Tuple, List] = (),
) -> Generator[Union[Metric, Result], None, bool]:
result_state = state(legacy_state)
if legacy_state or legacy_text: # skip "Null"-Result
if is_details:
summary: Optional[str] = None
details: Optional[str] = legacy_text
else:
is_details = "\n" in legacy_text
summary, details = legacy_text.split("\n", 1) if is_details else (legacy_text, None)
yield Result(
state=result_state,
summary=summary or None,
details=details or None,
)
for metric in legacy_metrics:
# fill up with None:
name, value, warn, crit, min_, max_ = (
v for v, _ in itertools.zip_longest(metric, range(6)))
yield Metric(name, value, levels=(warn, crit), boundaries=(min_, max_))
return is_details
def test_node_returns_metric():
node_results = _check_function_node((_OK_RESULT, Metric("panic", 42)))
result = aggregate_node_details("test_node", node_results)
assert result is not None
assert result.state is state.OK
assert result.summary == ""
assert result.details == "[test_node]: I am fine"
def _create_new_result(
is_details: bool,
legacy_state: int,
legacy_text: str,
legacy_metrics: Union[Tuple, List] = (),
) -> Generator[Union[Metric, Result], None, bool]:
if legacy_state or legacy_text: # skip "Null"-Result
# Bypass the validation of the Result class:
# Legacy plugins may relie on the fact that once a newline
# as been in the output, *all* following ouput is sent to
# the details. That means we have to create Results with
# details only, which is prohibited by the original Result
# class.
yield Result(state=State(legacy_state), summary="Fake")._replace(
summary="" if is_details else legacy_text.split("\n", 1)[0],
details=legacy_text.strip(),
)
for metric in legacy_metrics:
if len(metric) < 2:
continue
name = str(metric[0])
value = _get_float(metric[1])
if value is None: # skip bogus metrics
continue
# fill up with None:
warn, crit, min_, max_ = (
_get_float(v)
for v, _ in itertools.zip_longest(metric[2:], range(4)))
yield Metric(name, value, levels=(warn, crit), boundaries=(min_, max_))
return ("\n" in legacy_text) or is_details
def test_cpu_threads():
section = Section(load=Load(0.1, 0.1, 0.1), num_cpus=4, num_threads=1234)
params: Dict[str, Any] = {}
result = set(check_cpu_threads(params, section))
assert result == {
Metric('threads', 1234.0),
Result(state=State.OK, summary='1234'),
}
def test_cluster_check_best_yield_best_nodes_metrics() -> None:
check_best = _get_cluster_check_function(_simple_check, mode="best")
assert list(m for m in check_best(section={
"Nodett": [0, 23],
"Nodebert": [1, 42],
}, ) if isinstance(m, Metric))[0] == Metric("n", 23) # Nodetts value
def test_check():
item = "mysql:reddb"
params = {"levels": (None, None)}
section = {"mysql": {"reddb": 42}}
assert list(mysql_capacity.check_capacity(item, params, section)) == [
Result(state=State.OK, summary="Size: 42 B"),
Metric("database_size", 42.0),
]
def test_cluster_check_worst_yield_selected_nodes_metrics() -> None:
check_worst = _get_cluster_check_function(
_simple_check,
mode="worst",
clusterization_parameters={"metrics_node": "Nodett"})
assert list(m for m in check_worst(section={
"Nodett": [0, 23],
"Nodebert": [1, 42],
}, ) if isinstance(m, Metric))[0] == Metric("n", 23) # Nodetts value
def test_cpu_threads():
section = Section(
load=Load(0.1, 0.1, 0.1),
num_cpus=4,
threads=Threads(count=1234),
)
params: Dict[str, Any] = {}
result = set(check_cpu_threads(params, section))
assert result == {
Metric("threads", 1234.0),
Result(state=State.OK, summary="1234"),
}
def _simple_check(section: Iterable[int]) -> CheckResult:
"""just a simple way to create test check results"""
for value in section:
try:
yield Result(state=State(value), summary="Hi")
except ValueError:
if value == -1:
yield IgnoreResults("yielded")
elif value == -2:
raise IgnoreResultsError("raised")
else:
yield Metric("n", value)
def check_levels(
value: float,
*,
levels_upper=None, # tpye: Optional[Tuple[float, float]]
levels_lower=None, # tpye: Optional[Tuple[float, float]]
metric_name: str = None,
render_func: Callable[[float], str] = None,
label: str = None,
boundaries: Optional[Tuple[Optional[float], Optional[float]]] = None,
) -> Generator[Union[Result, Metric], None, None]:
"""Generic function for checking a value against levels.
:param value: Currently measured value
:param levels_upper: Pair of upper thresholds. If value is larger than these, the
service goes to **WARN** or **CRIT**, respecively.
:param levels_lower: Pair of lower thresholds. If value is smaller than these, the
service goes to **WARN** or **CRIT**, respecively.
:param metric_name: Name of the datasource in the RRD that corresponds to this value
or None in order to skip perfdata
:param render_func: Single argument function to convert the value from float into a
human readable string.
readable fashion
:param label: Label to prepend to the output.
:param boundaries: Minimum and maximum to add to the metric.
"""
if render_func is None:
render_func = lambda f: "%.2f" % f
info_text = str(render_func(value)) # forgive wrong output type
if label:
info_text = "%s: %s" % (label, info_text)
value_state, levels_text = _do_check_levels(value, levels_upper, levels_lower, render_func)
yield Result(state=value_state, summary=info_text + levels_text)
if metric_name:
yield Metric(metric_name, value, levels=levels_upper, boundaries=boundaries)
([], checking.ITEM_NOT_FOUND),
(
[
Result(state=state.OK, notice="details"),
],
(0, "Everything looks OK - 1 detail available\ndetails", []),
),
(
[
Result(state=state.OK,
summary="summary1",
details="detailed info1"),
Result(state=state.WARN,
summary="summary2",
details="detailed info2"),
],
(1, "summary1, summary2(!)\ndetailed info1\ndetailed info2(!)",
[]),
),
(
[
Result(state=state.OK, summary="summary"),
Metric(name="name", value=42),
],
(0, "summary\nsummary", [("name", 42.0, None, None, None, None)]),
),
],
)
def test_aggregate_result(subresults, aggregated_results):
assert checking._aggregate_results(subresults) == aggregated_results
def test_node_returns_metric():
node_results = _check_function_node((_OK_RESULT, Metric("panic", 42)))
assert list(make_node_notice_results("test_node", node_results)) == [
Result(state=State.OK, notice="[test_node]: I am fine"),
]
def check_levels_predictive(
value: float,
*,
levels: Dict[str, Any],
metric_name: str,
render_func: Optional[Callable[[float], str]] = None,
label: Optional[str] = None,
boundaries: Optional[Tuple[Optional[float], Optional[float]]] = None,
) -> Generator[Union[Result, Metric], None, None]:
"""Generic function for checking a value against levels.
Args:
value: Currently measured value
levels: Predictive levels. These are used automatically.
Lower levels are imposed if the passed dictionary contains "lower"
as key, upper levels are imposed if it contains "upper" or
"levels_upper_min" as key.
If value is lower/higher than these, the service goes to **WARN**
or **CRIT**, respecively.
metric_name: Name of the datasource in the RRD that corresponds to this value
render_func: Single argument function to convert the value from float into a
human readable string.
readable fashion
label: Label to prepend to the output.
boundaries: Minimum and maximum to add to the metric.
"""
if render_func is None:
render_func = "{:.2f}".format
# validate the metric name, before we can get the levels.
_ = Metric(metric_name, value)
try:
ref_value, levels_tuple = cmk.base.prediction.get_levels(
plugin_contexts.host_name(),
plugin_contexts.service_description(),
metric_name,
levels,
"MAX",
)
if ref_value:
predictive_levels_msg = " (predicted reference: %s)" % render_func(ref_value)
else:
predictive_levels_msg = " (no reference for prediction yet)"
except MKGeneralException as e:
ref_value = None
levels_tuple = (None, None, None, None)
predictive_levels_msg = " (no reference for prediction: %s)" % e
except Exception as e:
if cmk.utils.debug.enabled():
raise
yield Result(state=State.UNKNOWN, summary="%s" % e)
return
levels_upper = (None if levels_tuple[0] is None or levels_tuple[1] is None else
(levels_tuple[0], levels_tuple[1]))
levels_lower = (None if levels_tuple[2] is None or levels_tuple[3] is None else
(levels_tuple[2], levels_tuple[3]))
value_state, levels_text = _do_check_levels(value, levels_upper, levels_lower, render_func)
if label:
info_text = "%s: %s%s" % (label, render_func(value), predictive_levels_msg)
else:
info_text = "%s%s" % (render_func(value), predictive_levels_msg)
yield Result(state=value_state, summary=info_text + levels_text)
yield Metric(metric_name, value, levels=levels_upper, boundaries=boundaries)
if ref_value:
yield Metric("predict_%s" % metric_name, ref_value)
def test_metric_invalid(name, value, levels, boundaries):
with pytest.raises(TypeError):
_ = Metric(name, value, levels=levels, boundaries=boundaries)
def test_metric_kwarg():
with pytest.raises(TypeError):
_ = Metric("universe", 42, (23, 23)) # type: ignore[misc] # pylint: disable=too-many-function-args
(1, (3, 6), (1, 0), int, (State.OK, "")),
(0, (3, 6), (1, 0), int, (State.WARN, " (warn/crit below 1/0)")),
(-1, (3, 6), (1, 0), int, (State.CRIT, " (warn/crit below 1/0)")),
])
def test_boundaries(value, levels_upper, levels_lower, render_func, result):
assert utils._do_check_levels(value, levels_upper, levels_lower,
render_func) == result
@pytest.mark.parametrize("value, kwargs, result", [
(5, {
"metric_name": "battery",
"render_func": render.percent,
}, [
Result(state=State.OK, summary="5.00%"),
Metric("battery", 5.0),
]),
(6, {
"metric_name": "disk",
"levels_upper": (4, 8),
"render_func": lambda x: "%.2f years" % x,
"label": "Disk Age",
}, [
Result(
state=State.WARN,
summary="Disk Age: 6.00 years (warn/crit at 4.00 years/8.00 years)"
),
Metric("disk", 6.0, levels=(4., 8.)),
]),
(5e-7, {
"metric_name": "H_concentration",
result = set(check_cpu_threads(params, section))
assert result == {
Metric("thread_usage", 50.0),
Metric("threads", 1234.0),
Result(state=State.OK, summary="1234"),
Result(state=State.OK, summary="Usage: 50.00%"),
}
@pytest.mark.parametrize(
"info, check_result",
[
(
[["0.88", "0.83", "0.87", "2/2148", "21050", "8"]],
{
Metric("threads", 2148.0, levels=(2000.0, 4000.0)),
Result(state=State.WARN, summary="2148 (warn/crit at 2000/4000)"),
},
),
(
[["0.88", "0.83", "0.87", "2/1748", "21050", "8"], ["124069"]],
{
Metric("threads", 1748.0, levels=(2000.0, 4000.0)),
Result(state=State.OK, summary="1748"),
Metric("thread_usage", 1.408893438328672),
Result(state=State.OK, summary="Usage: 1.41%"),
},
),
],
)
def test_cpu_threads_regression(info, check_result):
num_cpus=4,
num_threads=1234,
max_threads=2468)
params: Dict[str, Any] = {}
result = set(check_cpu_threads(params, section))
assert result == {
Metric('thread_usage', 50.0),
Metric('threads', 1234.0),
Result(state=State.OK, summary='1234'),
Result(state=State.OK, summary='Usage: 50.00%')
}
@pytest.mark.parametrize('info, check_result', [
([[u'0.88', u'0.83', u'0.87', u'2/2148', u'21050', u'8']], {
Metric('threads', 2148.0, levels=(2000.0, 4000.0)),
Result(state=State.WARN, summary='2148 (warn/crit at 2000/4000)'),
}),
([[u'0.88', u'0.83', u'0.87', u'2/1748', u'21050', u'8'], [u'124069']], {
Metric('threads', 1748.0, levels=(2000.0, 4000.0)),
Result(state=State.OK, summary='1748'),
Metric('thread_usage', 1.408893438328672),
Result(state=State.OK, summary='Usage: 1.41%')
}),
])
def test_cpu_threads_regression(info, check_result):
section = parse_cpu(info)
assert section is not None
params = {'levels': (2000, 4000)}
assert list(discover_cpu_threads(section)) == [Service()]
assert set(check_cpu_threads(params, section)) == check_result
def test_node_returns_metric():
node_results = _check_function_node((_OK_RESULT, Metric("panic", 42)))
state, text = aggregate_node_details("test_node", node_results)
assert state is State.OK
assert text == "[test_node]: I am fine"