def _get_stats(self, what, context):
if what == "hosts":
context_filters, only_sites = visuals.get_filter_headers(table="hosts",
infos=["host"],
context=context)
query = self._get_host_stats_query(context_filters)
elif what == "services":
context_filters, only_sites = visuals.get_filter_headers(table="services",
infos=["host", "service"],
context=context)
query = self._get_service_stats_query(context_filters)
elif what == "events":
context_filters, only_sites = visuals.get_filter_headers(table="eventconsoleevents",
infos=["host", "event"],
context=context)
query = self._get_event_stats_query(context_filters)
else:
raise NotImplementedError()
return self._execute_stats_query(
query,
auth_domain="ec" if what == "events" else "read",
only_sites=only_sites,
deflt=[0, 0, 0] if what == "events" else None,
)
def _get_data(self, properties, context):
mode_properties = properties["render_mode"][1]
time_range = self._int_time_range_from_rangespec(
mode_properties["time_range"])
filter_headers, only_sites = get_filter_headers(
"log", self.filter_infos(), context)
object_type_filter = self._get_object_type_filter(properties)
query = (
"GET log\n"
"Columns: log_state host_name service_description log_type log_time\n"
"Filter: class = %d\n"
"Filter: log_time >= %f\n"
"Filter: log_time <= %f\n"
"%s"
"%s" % (self.log_class, time_range[0], time_range[1],
object_type_filter, lqencode(filter_headers)))
with sites.only_sites(only_sites):
try:
return sites.live().query(query)
except MKTimeout:
raise
except Exception:
raise MKGeneralException(_("The query returned no data."))
def _get_data(cls, properties, context, return_column_headers=True):
time_range = cls._int_time_range_from_rangespec(
properties["time_range"])
# TODO KO: check typing
c_headers = "ColumnHeaders: on\n" if return_column_headers else ""
filter_headers, only_sites = get_filter_headers(
"log", cls.filter_infos(), context)
query = (
"GET log\n"
"Columns: log_state host_name service_description log_type log_time\n"
"%s"
"Filter: class = %d\n"
"Filter: log_time >= %f\n"
"Filter: log_time <= %f\n"
"Filter: log_type ~ %s .*\n"
"%s" % (c_headers, cls.log_class(), time_range[0], time_range[1],
lqencode(properties["log_target"].upper()),
lqencode(filter_headers)))
try:
if only_sites:
sites.live().set_only_sites(only_sites)
rows = sites.live().query(query)
except MKTimeout:
raise
except Exception:
raise MKGeneralException(_("The query returned no data."))
finally:
sites.live().set_only_sites(None)
# TODO: hdrs has the funny type Union[str, LivestatusRow], is this really what we want?
hdrs = rows.pop(0) if return_column_headers else ""
return rows, hdrs
def _table_query(
properties, context, column_generator, table: str, infos: List[str]
) -> Tuple[List[str], LivestatusResponse]:
filter_headers, only_sites = visuals.get_filter_headers(table, infos, context)
columns = column_generator(properties, context)
query = (
f"GET {table}\n"
"Columns: %(cols)s\n"
"%(filter)s"
% {
"cols": " ".join(columns),
"filter": filter_headers,
}
)
with sites.only_sites(only_sites), sites.prepend_site():
try:
rows = sites.live().query(query)
except MKTimeout:
raise
except Exception:
raise MKGeneralException(_("The query returned no data."))
return ["site"] + columns, rows
def _get_livestatus(self, context):
context_filters, only_sites = visuals.get_filter_headers(
table=self.livestatus_table(),
infos=self.filter_infos(),
context=context)
return self._execute_query(self._get_query(context_filters),
only_sites)
def _get_filter_headers_of_context(
self,
datasource_name,
context,
single_infos,
) -> Tuple[str, livestatus.OnlySites]:
return get_filter_headers("", data_source_registry[datasource_name]().infos, context)
def _get_hosts(self):
context_filters, only_sites = visuals.get_filter_headers(
table="hosts",
infos=["host"],
context=self.parameters()["context"])
return self._execute_host_query(self._get_host_query(context_filters),
only_sites)
def _get_host_stats(cls, site_id: SiteId, context) -> Dict[HostName, HostStats]:
filter_headers, _only_sites = visuals.get_filter_headers(table="hosts",
infos=["host"],
context=context)
try:
sites.live().set_only_sites([site_id])
rows: LivestatusResponse = sites.live().query(cls._host_stats_query() + "\n" +
filter_headers)
finally:
sites.live().set_only_sites(None)
return {row[0]: HostStats(*row[1:]) for row in rows}
def _get_stats(cls, context, settings):
filter_headers, only_sites = visuals.get_filter_headers(
table=cls._livestatus_table(), infos=settings["infos"], context=context
)
query = cls._stats_query() + "\n" + filter_headers
try:
if only_sites:
with sites.only_sites(only_sites):
result: List[int] = sites.live().query_row(query)
else:
result = sites.live().query_summed_stats(query)
except MKLivestatusNotFoundError:
result = []
return cls._named_stats(result)
def _get_data(cls, properties, context):
time_range = cls._int_time_range_from_rangespec(properties["time_range"])
filter_headers, only_sites = get_filter_headers("log", cls.filter_infos(), context)
query = ("GET log\n"
"Columns: log_state host_name service_description log_type log_time\n"
"Filter: class = %d\n"
"Filter: log_time >= %f\n"
"Filter: log_time <= %f\n"
"Filter: log_type ~ %s .*\n"
"%s" % (cls.log_class(), time_range[0], time_range[1],
lqencode(properties["log_target"].upper()), lqencode(filter_headers)))
with sites.only_sites(only_sites):
try:
return sites.live().query(query)
except MKTimeout:
raise
except Exception as _e:
raise MKGeneralException(_("The query returned no data."))
def __call__(self, cls, properties, context):
filter_headers, only_sites = visuals.get_filter_headers("log", ["host", "service"], context)
columns = self.f(cls, properties, context)
query = ("GET services\n"
"Columns: %(cols)s\n"
"%(filter)s" % {
"cols": " ".join(columns),
"filter": filter_headers,
})
with sites.only_sites(only_sites), sites.prepend_site():
try:
rows = sites.live().query(query)
except MKTimeout:
raise
except Exception:
raise MKGeneralException(_("The query returned no data."))
return ['site'] + columns, rows
def _fetch_simple_number_data(self, properties, context):
mode_properties = properties["render_mode"][1]
time_range = self._int_time_range_from_rangespec(
mode_properties["time_range"])
filter_headers, only_sites = get_filter_headers(
"log", self.filter_infos(), context)
object_type_filter = self._get_object_type_filter(properties)
query = ("GET log\n"
"Stats: log_type != \n"
"Filter: class = %d\n"
"Filter: log_time >= %f\n"
"Filter: log_time <= %f\n"
"%s"
"%s" % (self.log_class, time_range[0], time_range[1],
object_type_filter, lqencode(filter_headers)))
with sites.only_sites(only_sites):
try:
return sites.live().query_summed_stats(query)
except livestatus.MKLivestatusNotFoundError:
raise MKGeneralException(_("The query returned no data."))
def _get_data(cls, properties, context, return_column_headers=True):
time_range = cls.int_time_range_from_rangespec(properties["time_range"])
c_headers = "ColumnHeaders: on\n" if return_column_headers else ""
filter_headers, only_sites = get_filter_headers("log", ["host", "service"], context)
metrics = {
"CPU load": "load1",
"CPU utilization": "util",
}
service_desc = properties["service"]
query = (
"GET services\n"
"Columns: host_name host_state service_description service_state service_check_command service_metrics service_perf_data rrddata:v1:%(metric)s:%(start)s:%(end)s:%(step)s\n"
# rrddata:m1:load1.max:%(start)s:%(end)s:%(step)s rrddata:m5:load5.max:%(start)s:%(end)s:%(step)s rrddata:m15:load15.max:%(start)s:%(end)s:%(step)s
"%(column)s"
"Filter: service_description ~~ %(service)s\n"
"%(filter)s" % {
"metric": metrics[service_desc],
"start": time_range[0],
"end": time_range[1],
"step": 300,
"service": service_desc,
"column": c_headers,
"filter": filter_headers,
})
with sites.only_sites(only_sites), sites.prepend_site():
try:
rows = sites.live().query(query)
except MKTimeout:
raise
except Exception:
raise MKGeneralException(_("The query returned no data."))
if return_column_headers:
return rows[0], rows[1:]
return rows, ""
def show(self):
pie_id = "dashlet_%d" % self._dashlet_id
pie_diameter = 130
pie_left_aspect = 0.5
pie_right_aspect = 0.8
table = self._table()
filter_headers, only_sites = visuals.get_filter_headers(
table=self._livestatus_table(),
infos=self.infos(),
context=self.context)
query = "GET %s\n" % self._livestatus_table()
for entry in table:
query += entry[3]
query += self._filter() + filter_headers
if only_sites:
try:
sites.live().set_only_sites(only_sites)
result = sites.live().query_row(query)
finally:
sites.live().set_only_sites()
else:
try:
result = sites.live().query_summed_stats(query)
except MKLivestatusNotFoundError:
result = []
pies = list(zip(table, result))
total = sum([x[1] for x in pies])
html.open_div(class_="stats")
html.canvas('',
class_="pie",
id_="%s_stats" % pie_id,
width=pie_diameter,
height=pie_diameter,
style="float: left")
html.img(html.theme_url("images/globe.png"), class_="globe")
html.open_table(class_=["hoststats"] +
(["narrow"] if len(pies) > 0 else []),
style="float:left")
table_entries = pies
while len(table_entries) < 6:
table_entries = table_entries + [(
("", None, [], ""), HTML(" "))]
table_entries.append(((_("Total"), "", [], ""), total))
for (name, color, table_url_vars, query), count in table_entries:
url_vars = [
("view_name", self._view_name()),
("filled_in", "filter"),
("search", "1"),
] + table_url_vars + self._dashlet_context_vars()
url = html.makeuri_contextless(url_vars, filename="view.py")
html.open_tr()
html.th(html.render_a(name, href=url))
html.td('',
class_="color",
style="background-color: %s" % color if color else '')
html.td(html.render_a(count, href=url))
html.close_tr()
html.close_table()
pie_parts = []
if total > 0:
# Count number of non-empty classes
num_nonzero = 0
for _info, value in pies:
if value > 0:
num_nonzero += 1
# Each non-zero class gets at least a view pixels of visible thickness.
# We reserve that space right now. All computations are done in percent
# of the radius.
separator = 0.02 # 3% of radius
remaining_separatorspace = num_nonzero * separator # space for separators
remaining_radius = 1 - remaining_separatorspace # remaining space
remaining_part = 1.0 # keep track of remaining part, 1.0 = 100%
# Loop over classes, begin with most outer sphere. Inner spheres show
# worse states and appear larger to the user (which is the reason we
# are doing all this stuff in the first place)
for (name, color, _unused, _q), value in pies[::1]:
if value > 0 and remaining_part > 0: # skip empty classes
# compute radius of this sphere *including all inner spheres!* The first
# sphere always gets a radius of 1.0, of course.
radius = remaining_separatorspace + remaining_radius * (
remaining_part**(1 / 3.0))
pie_parts.append('chart_pie("%s", %f, %f, %r, true);' %
(pie_id, pie_right_aspect, radius, color))
pie_parts.append('chart_pie("%s", %f, %f, %r, false);' %
(pie_id, pie_left_aspect, radius, color))
# compute relative part of this class
part = float(value) / total # ranges from 0 to 1
remaining_part -= part
remaining_separatorspace -= separator
html.close_div()
html.javascript(
"""
function chart_pie(pie_id, x_scale, radius, color, right_side) {
var context = document.getElementById(pie_id + "_stats").getContext('2d');
if (!context)
return;
var pie_x = %(x)f;
var pie_y = %(y)f;
var pie_d = %(d)f;
context.fillStyle = color;
context.save();
context.translate(pie_x, pie_y);
context.scale(x_scale, 1);
context.beginPath();
if(right_side)
context.arc(0, 0, (pie_d / 2) * radius, 1.5 * Math.PI, 0.5 * Math.PI, false);
else
context.arc(0, 0, (pie_d / 2) * radius, 0.5 * Math.PI, 1.5 * Math.PI, false);
context.closePath();
context.fill();
context.restore();
context = null;
}
if (cmk.dashboard.has_canvas_support()) {
%(p)s
}
""" % {
"x": int(pie_diameter / 2.0),
"y": int(pie_diameter / 2.0),
"d": pie_diameter,
'p': '\n'.join(pie_parts)
})
