/usr/lib/python3/dist-packages/nagiosplugin/context.py is in python3-nagiosplugin 1.2.4-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 | """Metadata about metrics to perform data :term:`evaluation`.
This module contains the :class:`Context` class, which is the base for
all contexts. :class:`ScalarContext` is an important specialization to
cover numeric contexts with warning and critical thresholds. The
:class:`~.check.Check` controller selects a context for each
:class:`~.metric.Metric` by matching the metric's `context` attribute with the
context's `name`. The same context may be used for several metrics.
Plugin authors may just use to :class:`ScalarContext` in the majority of cases.
Sometimes is better to subclass :class:`Context` instead to implement custom
evaluation or performance data logic.
"""
from .performance import Performance
from .range import Range
from .result import Result
from .state import Ok, Warn, Critical
class Context(object):
def __init__(self, name, fmt_metric=None, result_cls=Result):
"""Creates generic context identified by `name`.
Generic contexts just format associated metrics and evaluate
always to :obj:`~nagiosplugin.state.Ok`. Metric formatting is
controlled with the :attr:`fmt_metric` attribute. It can either
be a string or a callable. See the :meth:`describe` method for
how formatting is done.
:param name: context name that is matched by the context
attribute of :class:`~nagiosplugin.metric.Metric`
:param fmt_metric: string or callable to convert
context and associated metric to a human readable string
:param result_cls: use this class (usually a
:class:`~.result.Result` subclass) to represent the
evaluation outcome
"""
self.name = name
self.fmt_metric = fmt_metric
self.result_cls = result_cls
def evaluate(self, metric, resource):
"""Determines state of a given metric.
This base implementation returns :class:`~nagiosplugin.state.Ok`
in all cases. Plugin authors may override this method in
subclasses to specialize behaviour.
:param metric: associated metric that is to be evaluated
:param resource: resource that produced the associated metric
(may optionally be consulted)
:returns: :class:`~.result.Result` or
:class:`~.state.ServiceState` object
"""
return self.result_cls(Ok, metric=metric)
def performance(self, metric, resource):
"""Derives performance data from a given metric.
This base implementation just returns none. Plugin authors may
override this method in subclass to specialize behaviour.
:param metric: associated metric from which performance data are
derived
:param resource: resource that produced the associated metric
(may optionally be consulted)
:returns: :class:`Perfdata` object or `None`
"""
return None
def describe(self, metric):
"""Provides human-readable metric description.
Formats the metric according to the :attr:`fmt_metric`
attribute. If :attr:`fmt_metric` is a string, it is evaluated as
format string with all metric attributes in the root namespace.
If :attr:`fmt_metric` is callable, it is called with the metric
and this context as arguments. If :attr:`fmt_metric` is not set,
this default implementation does not return a description.
Plugin authors may override this method in subclasses to control
text output more tightly.
:param metric: associated metric
:returns: description string or None
"""
if not self.fmt_metric:
return
try:
return self.fmt_metric(metric, self)
except TypeError:
return self.fmt_metric.format(
name=metric.name, value=metric.value, uom=metric.uom,
valueunit=metric.valueunit, min=metric.min, max=metric.max)
class ScalarContext(Context):
def __init__(self, name, warning=None, critical=None,
fmt_metric='{name} is {valueunit}', result_cls=Result):
"""Ready-to-use :class:`Context` subclass for scalar values.
ScalarContext models the common case where a single scalar is to
be evaluated against a pair of warning and critical thresholds.
:attr:`name`, :attr:`fmt_metric`, and :attr:`result_cls`,
are described in the :class:`Context` base class.
:param warning: Warning threshold as
:class:`~nagiosplugin.range.Range` object or range string.
:param critical: Critical threshold as
:class:`~nagiosplugin.range.Range` object or range string.
"""
super(ScalarContext, self).__init__(name, fmt_metric, result_cls)
self.warning = Range(warning)
self.critical = Range(critical)
def evaluate(self, metric, resource):
"""Compares metric with ranges and determines result state.
The metric's value is compared to the instance's :attr:`warning`
and :attr:`critical` ranges, yielding an appropropiate state
depending on how the metric fits in the ranges. Plugin authors
may override this method in subclasses to provide custom
evaluation logic.
:param metric: metric that is to be evaluated
:param resource: not used
:returns: :class:`~nagiosplugin.result.Result` object
"""
if not self.critical.match(metric.value):
return self.result_cls(Critical, self.critical.violation, metric)
elif not self.warning.match(metric.value):
return self.result_cls(Warn, self.warning.violation, metric)
else:
return self.result_cls(Ok, None, metric)
def performance(self, metric, resource):
"""Derives performance data.
The metric's attributes are combined with the local
:attr:`warning` and :attr:`critical` ranges to get a
fully populated :class:`~nagiosplugin.performance.Performance`
object.
:param metric: metric from which performance data are derived
:param resource: not used
:returns: :class:`~nagiosplugin.performance.Performance` object
"""
return Performance(metric.name, metric.value, metric.uom,
self.warning, self.critical,
metric.min, metric.max)
class Contexts:
"""Container for collecting all generated contexts."""
def __init__(self):
self.by_name = dict(
default=ScalarContext('default', '', ''),
null=Context('null'))
def add(self, context):
self.by_name[context.name] = context
def __getitem__(self, context_name):
try:
return self.by_name[context_name]
except KeyError:
raise KeyError('cannot find context', context_name,
'known contexts: {0}'.format(
', '.join(self.by_name.keys())))
def __contains__(self, context_name):
return context_name in self.by_name
def __iter__(self):
return iter(self.by_name)
|