)),
Integer(title=_(
"Critical if at least this number of important updates are pending"
)),
Integer(title=_(
"Warning if at least this number of optional updates are pending"
)),
Integer(title=_(
"Critical if at least this number of optional updates are pending"
)),
Age(title=_("Warning if time until forced reboot is less then"),
default_value=604800),
Age(
title=_(
"Critical if time time until forced reboot is less then"),
default_value=172800,
),
Checkbox(title=_("display all important updates verbosely"),
default_value=True),
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="windows_updates",
group=RulespecGroupCheckParametersApplications,
parameter_valuespec=_parameter_valuespec_windows_updates,
title=lambda: _("WSUS (Windows Updates)"),
))
unit="nodes"),
],
),
),
],
optional_keys=[
"number_of_nodes", "number_of_data_nodes", "green", "yellow", "red"
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="elasticsearch_cluster_health",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_elasticsearch_cluster_health,
title=lambda: _("Elasticsearch Cluster Health"),
))
def _parameter_valuespec_elasticsearch_cluster_shards():
return Dictionary(
elements=[
(
"active_shards",
Tuple(
title=_(
"Expected number of active shards in absolute number"),
elements=[
Integer(title=_("Warning if less then"),
def _parameter_valuespec_proxmox_ve_vm_info():
# use Dictionary as Optional returning an empty dict if empty
return Dictionary(
title=_("Check Parameter"),
elements=[
(
"required_vm_status",
Optional(
title=_("Modify: Check VM Status (off: keep default)"),
label=_("Activate Check (off: ignore VM status)"),
default_value=True,
valuespec=TextInput(
title=_("Warn if VM status value is not"),
default_value="running",
),
),
)
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
title=lambda: _("Proxmox VE VM Info"),
check_group_name="proxmox_ve_vm_info",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_proxmox_ve_vm_info,
)
)
MEMORY_DEFAULT = 1024**3
def _memory_tuple(title):
return Tuple(
title=title,
elements=[
Filesize(title=_("Warning at"), default_value=MEMORY_DEFAULT),
Filesize(title=_("Critical at"), default_value=MEMORY_DEFAULT),
],
)
def _parameter_valuespec_esx_host_memory():
return Dictionary(elements=[
("host", _memory_tuple(_("Host memory usage"))),
("guest", _memory_tuple(_("Guest memory usage"))),
("ballooned", _memory_tuple(_("Ballooned memory usage"))),
("private", _memory_tuple(_("Private memory usage"))),
("shared", _memory_tuple(_("Shared memory usage"))),
])
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="esx_vsphere_vm_memory",
group=RulespecGroupCheckParametersOperatingSystem,
parameter_valuespec=_parameter_valuespec_esx_host_memory,
title=lambda: _("ESX VM memory usage"),
))
],
),
),
(
"average",
Integer(
title=_("Averaging"),
help=
_("If this parameter is set, all measured values will be averaged "
"over the specified time interval before levels are being applied. Per "
"default, averaging is turned off."),
unit=_("minutes"),
minvalue=1,
default_value=60,
),
),
],
optional_keys=["average"],
),
forth=lambda t: isinstance(t, tuple) and {"levels": t} or t,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="memory",
group=RulespecGroupCheckParametersOperatingSystem,
parameter_valuespec=_parameter_valuespec_memory,
title=lambda: _("Main memory usage (UNIX / Other Devices)"),
))
"expired",
Tuple(
title=_('Upper levels for "expired objects" per second'),
elements=[
Float(title=_("Warning at"), default_value=1.0),
Float(title=_("Critical at"), default_value=2.0),
],
),
),
(
"lru_nuked",
Tuple(
title=_('Upper levels for "LRU nuked objects" per second'),
elements=[
Float(title=_("Warning at"), default_value=1.0),
Float(title=_("Critical at"), default_value=2.0),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="varnish_objects",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_varnish_objects,
title=lambda: _("Varnish Objects"),
))
def _parameter_valuespec_citrix_state():
return Dictionary(elements=[(
"registrationstate",
Dictionary(
title=_("Interpretation of Registration States"),
elements=[
("Unregistered",
MonitoringState(title=_("Unregistered"), default_value=2)),
("Initializing",
MonitoringState(title=_("Initializing"), default_value=1)),
("Registered",
MonitoringState(title=_("Registered"), default_value=0)),
("AgentError",
MonitoringState(title=_("Agent Error"), default_value=2)),
],
optional_keys=False,
),
)], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="citrix_state",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_citrix_state,
title=lambda: _("Citrix VM state"),
))
Integer(title=_("Time interval"),
unit="minutes",
default_value=10),
],
),
),
(
"last_time",
Tuple(
title=_("Last flush time"),
elements=[
Integer(title=_("Warning at"), unit="ms",
default_value=50),
Integer(title=_("Critical at"),
unit="ms",
default_value=100),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="mongodb_flushing",
group=RulespecGroupCheckParametersStorage,
match_type="dict",
parameter_valuespec=_parameter_valuespec_mongodb_flushing,
title=lambda: _("MongoDB Flushes"),
))
Tuple(
title=_("User CPU usage"),
elements=[
Percentage(title=_("Warning at")),
Percentage(title=_("Critical at")),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="k8s_pods_cpu",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_k8s_pods_cpu,
title=lambda: _("Kubernetes Namespaced pods cpu usage"),
is_deprecated=True,
))
def _parameter_valuespec_k8s_pods_memory():
return Dictionary(elements=[
(
"rss",
Tuple(
title=_("Resident memory usage"),
elements=[
Filesize(title=_("Warning at")),
Filesize(title=_("Critical at")),
],
from cmk.gui.i18n import _
from cmk.gui.plugins.wato.utils import (
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersOperatingSystem,
)
from cmk.gui.valuespec import Dictionary, Integer, Tuple
def _parameter_valuespec_mem_pages():
return Dictionary(elements=[(
"pages_per_second",
Tuple(
title=_("Pages per second"),
elements=[
Integer(title=_("Warning at"), unit=_("pages/s")),
Integer(title=_("Critical at"), unit=_("pages/s")),
],
),
)], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="mem_pages",
group=RulespecGroupCheckParametersOperatingSystem,
match_type="dict",
parameter_valuespec=_parameter_valuespec_mem_pages,
title=lambda: _("Memory Pages Statistics"),
))
elements=[
(
"levels",
Tuple(
title=_("Levels"),
elements=[
Percentage(
title=_("Warning at"),
default_value=70.0,
),
Percentage(
title=_("Critical at"),
default_value=80.0,
),
],
),
),
],
required_keys=["levels"], # There is only one value, so its required
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="memory_percentage_used",
group=RulespecGroupCheckParametersOperatingSystem,
match_type="dict",
parameter_valuespec=_parameter_valuespec_memory_percentage_levels,
title=lambda: _("Memory percentage used"),
))
display=["hours", "minutes"],
default_value=300,
),
Age(
title=_("Critical at"),
display=["hours", "minutes"],
default_value=3600,
),
],
),
),
], ),
forth=_transform_forth,
)
def _transform_forth(params):
if isinstance(params, dict):
return params
return {"ntp_levels": params}
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="ntp_time",
group=RulespecGroupCheckParametersOperatingSystem,
match_type="dict",
parameter_valuespec=_parameter_valuespec_ntp_time,
title=lambda: _("State of NTP time synchronisation"),
))
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersOperatingSystem,
)
from cmk.gui.valuespec import Dictionary, Percentage, Tuple
def _parameter_valuespec_sophos_disk():
return Dictionary(elements=[
(
"disk_levels",
Tuple(
title=_("Disk percentage usage"),
elements=[
Percentage(title=_("Warning at"), default_value=80),
Percentage(title=_("Critical at"), default_value=90),
],
),
),
])
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="sophos_disk",
group=RulespecGroupCheckParametersOperatingSystem,
match_type="dict",
parameter_valuespec=_parameter_valuespec_sophos_disk,
title=lambda: _("Sophos Disk utilization"),
))
(
"upper",
Tuple(elements=[
Float(
title=_("Warning at"),
unit=_("per second"),
default_value=1.0,
),
Float(
title=_("Critical at"),
unit=_("per second"),
default_value=2.0,
),
], ),
),
],
optional_keys=[],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="skype_sip",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_skype_sip,
title=lambda: _("Skype for Business SIP Stack"),
))
),
(
"UsePAM",
DropdownChoice(
title=_("Use pluggable authentication module"),
choices=[
("yes", _("Yes")),
("no", _("No")),
],
default_value="no",
),
),
(
"Ciphers",
ListOfStrings(
title=_("Allowed Ciphers"),
orientation="horizontal",
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="sshd_config",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_sshd_config,
title=lambda: _("SSH daemon configuration"),
))
)
from cmk.gui.valuespec import Dictionary, Float, Tuple
def _parameter_valuespec_fortimail_cpu_load():
return Dictionary(
elements=[
(
"cpu_load",
Tuple(
elements=[
Float(title=_("Warning at")),
Float(title=_("Critical at")),
],
title=_("CPU load"),
help=("Set levels on the CPU load."),
),
),
],
optional_keys=False,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="fortimail_cpu_load",
group=RulespecGroupCheckParametersOperatingSystem,
parameter_valuespec=_parameter_valuespec_fortimail_cpu_load,
title=lambda: _("Fortinet FortiMail CPU load"),
))
Integer(title=_("warning at"), unit="°C",
default_value=26),
Integer(title=_("critical at"),
unit="°C",
default_value=30),
],
),
),
(
"humidity",
Tuple(
title=_("Humidity"),
elements=[
Integer(title=_("warning at"), unit="%", default_value=60),
Integer(title=_("critical at"), unit="%",
default_value=75),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="eaton_enviroment",
group=RulespecGroupCheckParametersEnvironment,
match_type="dict",
parameter_valuespec=_parameter_valuespec_eaton_enviroment,
title=lambda: _("Temperature and Humidity for Eaton UPS"),
))
),
),
(
"exclude_pattern",
RegExp(
title=_("Regular expression to exclude plugins"),
mode=RegExp.infix,
help=_(
"Plugins or local checks matching this pattern will be excluded from the "
"comparison with the specified required versions."
),
),
),
],
help=_('This ruleset is deprecated. Please use the ruleset <i>"%s"</i> instead.')
% _("Checkmk Agent installation auditing"),
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="checkmk_agent_plugins",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_checkmk_agent_plugins,
title=lambda: _("Checkmk agent plugins") + " - " + _("Deprecated"),
# only present during 2.1.0b1. remove in 2.2!
is_deprecated=True,
)
)
(
"levels",
Tuple(
title=_("Levels"),
elements=[
Percentage(
title=_("Warning at"),
default_value=80.0,
),
Percentage(
title=_("Critical at"),
default_value=90.0,
),
],
),
),
],
required_keys=["levels"], # There is only one value, so its required
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="proxmox_ve_disk_percentage_used",
group=RulespecGroupCheckParametersOperatingSystem,
match_type="dict",
parameter_valuespec=_parameter_valuespec_proxmox_ve_disk_percentage_levels,
title=lambda: _("Proxmox VE disk percentage used"),
)
)
],
)
def _parameter_valuespec_fortinet_signatures():
return Dictionary(elements=[
("av_age", _vs_fortinet_signatures(_("Age of Anti-Virus signature"))),
(
"av_ext_age",
_vs_fortinet_signatures(
_("Age of Anti-Virus signature extended database")),
),
("ips_age",
_vs_fortinet_signatures(_("Age of Intrusion Prevention signature"))),
(
"ips_ext_age",
_vs_fortinet_signatures(
_("Age of Intrusion Prevention signature extended database")),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="fortinet_signatures",
group=RulespecGroupCheckParametersNetworking,
match_type="dict",
parameter_valuespec=_parameter_valuespec_fortinet_signatures,
title=lambda: _("Fortigate Signatures"),
))
(option,
age_levels_dropdown(option, default_choice=default_choice))
for option in options)
elements.append((
"other",
age_levels_dropdown(title="Other", default_choice="no_levels"),
))
return lambda: Dictionary(
title=_("Interpretation of pod status"),
help=
_("Map the Kubernetes pod status shown in the summary to an upper level of its age. "
"In order the configure pod statuses not within the list below, use the 'Other' option."
),
elements=elements,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="kube_pod_status",
group=RulespecGroupCheckParametersApplications,
parameter_valuespec=_parameter_valuespec_kube_pod_status([
Section(options=CONTAINER_STATUSES, default_choice="levels"),
Section(options=INIT_STATUSES, default_choice="levels"),
Section(options=DESIRED_PHASE, default_choice="no_levels"),
Section(options=UNDESIRED_PHASE, default_choice="levels"),
]),
title=lambda: _("Kubernetes pod status"),
))
"applications, without swapping. Calculated from MemFree, "
"SReclaimable, the size of the file LRU lists, and the low "
"watermarks in each zone. "
"The estimate takes into account that the system needs some "
"page cache to function well, and that not all reclaimable "
"slab will be reclaimable, due to items being in use. The "
'impact of those factors will vary from system to system." '
"(https://www.kernel.org/doc/Documentation/filesystems/proc.txt)"
),
),
),
("levels_vmalloc",
LowerMemoryLevels(_("Largest Free VMalloc Chunk"))),
(
"levels_hardwarecorrupted",
UpperMemoryLevels(_("Hardware Corrupted"), (1, 1), _("RAM")),
),
], ),
forth=transform_memory_levels,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="memory_linux",
group=RulespecGroupCheckParametersOperatingSystem,
match_type="dict",
parameter_valuespec=_parameter_valuespec_memory_linux,
title=lambda: _("Memory and Swap usage on Linux"),
))
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright (C) 2019 tribe29 GmbH - License: GNU General Public License v2
# This file is part of Checkmk (https://checkmk.com). It is subject to the terms and
# conditions defined in the file COPYING, which is part of this source code package.
from cmk.gui.i18n import _
from cmk.gui.plugins.wato.check_parameters.memory_arbor import DualMemoryLevels
from cmk.gui.plugins.wato.utils import (
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersApplications,
)
from cmk.gui.valuespec import Dictionary
def _parameter_valuespec_memory():
return Dictionary(elements=[
("levels_ram", DualMemoryLevels(_("RAM"))),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="k8s_memory",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_memory,
title=lambda: _("Memory usage for Kubernetes objects"),
))
from cmk.gui.plugins.wato.utils import (
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersEnvironment,
)
from cmk.gui.valuespec import Age, Tuple
def _parameter_valuespec_lamp_operation_time():
return Tuple(elements=[
Age(
title=_("Warning at"),
default_value=1000 * 3600,
display=["hours"],
),
Age(
title=_("Critical at"),
default_value=1500 * 3600,
display=["hours"],
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="lamp_operation_time",
group=RulespecGroupCheckParametersEnvironment,
parameter_valuespec=_parameter_valuespec_lamp_operation_time,
title=lambda: _("Beamer lamp operation time"),
))
label=_("% of Flash"),
maxvalue=None,
),
Percentage(
title=_("Critical at a usage of"),
# xgettext: no-python-format
label=_("% of Flash"),
maxvalue=None,
),
],
),
Tuple(
title=_("Specify levels in absolute usage values"),
elements=[
Integer(title=_("Warning at"), unit=_("MB")),
Integer(title=_("Critical at"), unit=_("MB")),
],
),
]
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="general_flash_usage",
group=RulespecGroupCheckParametersOperatingSystem,
parameter_valuespec=_parameter_valuespec_general_flash_usage,
title=lambda: _("Flash Space Usage"),
)
)
"number_of_spare_disks",
Tuple(
title=_("Number of spare disks"),
help=
_("You can set a lower limit to the absolute number of spare disks."
),
elements=[
Integer(title=_("Warning below"),
default_value=2,
minvalue=0),
Integer(title=_("Critical below"),
default_value=1,
minvalue=0),
],
),
),
], ),
forth=lambda a: "broken_spare_ratio" in a and
{"failed_spare_ratio": a["broken_spare_ratio"]} or a,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="netapp_disks",
group=RulespecGroupCheckParametersStorage,
match_type="dict",
parameter_valuespec=_parameter_valuespec_netapp_disks,
title=lambda: _("Filer Disk Levels (NetApp, IBM SVC)"),
))
Integer(title=_("Critical below")),
],
),
),
],
)
def _parameter_valuespec():
return Dictionary(
help=
_("Allows to define absolute levels for running, waiting, terminated and total containers."
),
elements=[
("running", __levels(_("Number of running containers"))),
("waiting", __levels(_("Number of waiting containers"))),
("terminated", __levels(_("Number of terminated containers"))),
("total", __levels(_("Number of total containers"))),
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="k8s_node_container_count",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec,
title=lambda: _("Kubernetes node container count"),
))
default_value=(80.0, 90.0),
elements=[
Percentage(title=_("Warning above")),
Percentage(title=_("Critical above")),
],
),
),
(
"memory",
Tuple(
title=_("Memory"),
default_value=(80.0, 90.0),
elements=[
Percentage(title=_("Warning above")),
Percentage(title=_("Critical above")),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="k8s_resources",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_k8s_resources,
title=lambda: _("Kubernetes resources"),
is_deprecated=True,
))
title=_("Warning at"),
display=["days", "hours", "minutes"],
# bit more than a day
default_value=int(60 * 60 * 26),
),
Age(
title=_("Critical at"),
display=["days", "hours", "minutes"],
# bit more than two days
default_value=int(60 * 60 * 50),
),
],
),
FixedValue(value=None, title=_("No Conditions"), totext=""),
],
),
)
]
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
title=lambda: _("Proxmox VE VM Backup"),
check_group_name="proxmox_ve_vm_backup_status",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_proxmox_ve_vm_backup_requirements,
)
)
from cmk.gui.i18n import _
from cmk.gui.plugins.wato.utils import (
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersOperatingSystem,
)
from cmk.gui.valuespec import Integer, OptionalDropdownChoice, Tuple
def _parameter_valuespec_memory_relative():
return OptionalDropdownChoice(
title=_("Memory usage"),
choices=[(None, _("Do not impose levels"))],
otherlabel=_("Percentual levels ->"),
explicit=Tuple(elements=[
Integer(title=_("Warning at"), default_value=85, unit="%"),
Integer(title=_("Critical at"), default_value=90, unit="%"),
], ),
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="memory_relative",
group=RulespecGroupCheckParametersOperatingSystem,
parameter_valuespec=_parameter_valuespec_memory_relative,
title=lambda: _("Main memory usage for Brocade fibre channel switches"
),
))
