elements=[
Age(
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(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,
))
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersApplications,
)
from cmk.gui.valuespec import Dictionary, Integer, Tuple
def _parameter_valuespec_entersekt_ecerterrors():
return Dictionary(elements=[
(
"levels",
Tuple(
title=_("Upper levels for HTTP Ecert Errors"),
elements=[
Integer(title=_("Warning if above"), default_value=100),
Integer(title=_("Critical if above"), default_value=200),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="entersekt_ecerterrors",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_entersekt_ecerterrors,
title=lambda: _("Entersekt HTTP Ecert Errors"),
))
from cmk.gui.plugins.wato.utils import (
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersEnvironment,
)
from cmk.gui.valuespec import Dictionary, ListOf, MonitoringState, TextInput
def _parameter_valuespec_netapp_instance():
return ListOf(
valuespec=Dictionary(
help=_("This rule allows you to override netapp warnings"),
elements=[
("name", TextInput(title=_("Warning starts with"))),
("state", MonitoringState(title="Set state to",
default_value=1)),
],
optional_keys=False,
),
add_label=_("Add warning"),
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="netapp_instance",
group=RulespecGroupCheckParametersEnvironment,
parameter_valuespec=_parameter_valuespec_netapp_instance,
title=lambda: _("Netapp Instance State"),
))
)
from cmk.gui.valuespec import Dictionary, Integer, Tuple
def _parameter_valuespec_cisco_fw_connections():
return Dictionary(elements=[
(
"connections",
Tuple(
help=_(
"This rule sets limits to the current number of connections through "
"a Cisco ASA firewall."),
title=_("Maximum number of firewall connections"),
elements=[
Integer(title=_("Warning at")),
Integer(title=_("Critical at")),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="cisco_fw_connections",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_cisco_fw_connections,
title=lambda: _("Cisco ASA Firewall Connections"),
))
params["util"] = params.pop("levels")
return params
def _parameter_valuespec_cpu_utilization_os():
return Transform(
valuespec=_cpu_util_common_elements(),
forth=transform_legacy_cpu_utilization_os,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="cpu_utilization_os",
group=RulespecGroupCheckParametersOperatingSystem,
match_type="dict",
parameter_valuespec=_parameter_valuespec_cpu_utilization_os,
title=lambda: _("CPU utilization for simple devices"),
))
def transform_cpu_iowait(params):
if isinstance(params, tuple):
return {"iowait": params}
return params
def _parameter_valuespec_cpu_iowait():
return Transform(
valuespec=_cpu_util_common_elements(),
forth=transform_cpu_iowait,
"groups",
ListOf(
valuespec=__element(),
title=_("Groups"),
default_value=[
(
"no_levels",
DESIRED_PHASE,
),
(
("levels", (300, 600)),
[".*"],
),
],
add_label=_("Add new group"),
),
),
],
optional_keys=False,
indent=False,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="kube_pod_status",
group=RulespecGroupCheckParametersApplications,
parameter_valuespec=_parameter_valuespec_kube_pod_status,
title=lambda: _("Kubernetes pod status"),
))
help=
_("If this option is enabled, there will be one separate check for each logfile found during "
"the service discovery. This option also changes the behaviour for unknown logfiles. "
"The default logwatch check forwards all logfiles to the event console, even logfiles "
"which were not known during the service discovery. Creating one check per logfile changes "
"this behaviour so that any data from unknown logfiles is discarded."
),
),
),
],
optional_keys=[
"restrict_logfiles",
"expected_logfiles",
"logwatch_reclassify",
"separate_checks",
],
ignored_keys=["service_level"],
),
],
default_value="",
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="logwatch_ec",
group=RulespecGroupCheckParametersApplications,
parameter_valuespec=_parameter_valuespec_logwatch_ec,
title=lambda: _("Logwatch Event Console Forwarding"),
))
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersOperatingSystem,
)
from cmk.gui.valuespec import Dictionary, Percentage, Tuple
def _parameter_valuespec_sophos_memory():
return Dictionary(elements=[
(
"memory_levels",
Tuple(
title=_("Memory 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_memory",
group=RulespecGroupCheckParametersOperatingSystem,
match_type="dict",
parameter_valuespec=_parameter_valuespec_sophos_memory,
title=lambda: _("Sophos Memory utilization"),
))
title=_("Warn if node status value is not"),
default_value="online",
),
),
),
(
"required_subscription_status",
Optional(
title=_("Subscription Status"),
label=_("Activate Check (off: ignore subscription status)"),
default_value=True,
valuespec=TextInput(
title=_("Warn if subscription status value is not"),
default_value="Active",
),
),
),
]
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
title=lambda: _("Proxmox VE Node Info"),
check_group_name="proxmox_ve_node_info",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_proxmox_ve_node_info,
)
)
"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"),
))
from cmk.gui.i18n import _
from cmk.gui.plugins.wato.utils import (
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersApplications,
)
from cmk.gui.valuespec import Integer, Optional, Tuple
def _parameter_valuespec_vms_procs():
return Optional(
valuespec=Tuple(elements=[
Integer(title=_("Warning at"),
unit=_("processes"),
default_value=100),
Integer(title=_("Critical at"),
unit=_("processes"),
default_value=200),
], ),
title=_("Impose levels on number of processes"),
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="vms_procs",
group=RulespecGroupCheckParametersApplications,
parameter_valuespec=_parameter_valuespec_vms_procs,
title=lambda: _("OpenVMS processes"),
))
# conditions defined in the file COPYING, which is part of this source code package.
from cmk.gui.i18n import _
from cmk.gui.plugins.wato.utils import (
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersEnvironment,
)
from cmk.gui.valuespec import Integer, Tuple
def _parameter_valuespec_single_humidity():
return Tuple(
help=_("This Ruleset sets the threshold limits for humidity sensors"),
elements=[
Integer(title=_("Critical at or below"), unit="%"),
Integer(title=_("Warning at or below"), unit="%"),
Integer(title=_("Warning at or above"), unit="%"),
Integer(title=_("Critical at or above"), unit="%"),
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="single_humidity",
group=RulespecGroupCheckParametersEnvironment,
parameter_valuespec=_parameter_valuespec_single_humidity,
title=lambda: _("Humidity Levels for devices with a single sensor"),
))
),
),
(
"memdrop",
Tuple(
title=
_("Levels for rate of packets dropped due to memory limitations"
),
elements=[
Float(title=_("Warning at"),
unit=_("pkts/s"),
default_value=100.0),
Float(title=_("Critical at"),
unit=_("pkts/s"),
default_value=10000.0),
],
),
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="pfsense_counter",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_pfsense_counter,
title=lambda: _("pfSense Firewall Packet Rates"),
))
RulespecGroupCheckParametersApplications,
)
from cmk.gui.valuespec import Dictionary, Percentage, Tuple
def _parameter_valuespec_varnish_worker_thread_ratio():
return Dictionary(elements=[
(
"levels_lower",
Tuple(
title=_("Lower levels"),
elements=[
Percentage(title=_("Warning if below"),
default_value=70.0),
Percentage(title=_("Critical if below"),
default_value=60.0),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="varnish_worker_thread_ratio",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_varnish_worker_thread_ratio,
title=lambda: _("Varnish Worker Thread Ratio"),
))
return Tuple(
title=_("Time since last UPS selftest"),
elements=[
Integer(
title=_("Warning Level for time since last self test"),
help=_(
"Warning Level for time since last diagnostic test of the device. "
"For a value of 0 the warning level will not be used"),
unit=_("days"),
default_value=0,
),
Integer(
title=_("Critical Level for time since last self test"),
help=_(
"Critical Level for time since last diagnostic test of the device. "
"For a value of 0 the critical level will not be used"),
unit=_("days"),
default_value=0,
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="ups_test",
group=RulespecGroupCheckParametersEnvironment,
parameter_valuespec=_parameter_valuespec_ups_test,
title=lambda: _("Time since last UPS selftest"),
))
),
(
"warn_states",
ListChoice(
title=_("States which result in Warning"),
choices=bvip_link_states,
default_value=[7],
),
),
(
"crit_states",
ListChoice(
title=_("States which result in Critical"),
choices=bvip_link_states,
default_value=[1, 2, 3],
),
),
],
optional_keys=False,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="bvip_link",
group=RulespecGroupCheckParametersEnvironment,
match_type="dict",
parameter_valuespec=_parameter_valuespec_bvip_link,
title=lambda: _("Allowed Network states on Bosch IP Cameras"),
))
# -*- 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.utils import (
CheckParameterRulespecWithoutItem,
Levels,
rulespec_registry,
RulespecGroupCheckParametersApplications,
)
def _parameter_valuespec_safenet_ntls_links():
return Levels(
title=_("NTLS Links"),
default_value=None,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="safenet_ntls_links",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_safenet_ntls_links,
title=lambda: _("Safenet NTLS Links"),
)
)
],
),
),
(
"virtual_levels",
Tuple(
title=_("Virtual memory usage"),
help=
_("Virtual displays the quantity of virtual memory used by the mongod process. "
),
elements=[
Filesize(title=_("Warning at"),
default_value=2 * 1024**3),
Filesize(title=_("Critical at"),
default_value=4 * 1024**3),
],
),
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="mongodb_mem",
group=RulespecGroupCheckParametersStorage,
match_type="dict",
parameter_valuespec=_parameter_valuespec_mongodb_mem,
title=lambda: _("MongoDB Memory"),
))
# conditions defined in the file COPYING, which is part of this source code package.
from cmk.gui.i18n import _
from cmk.gui.plugins.wato.utils import (
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersApplications,
)
from cmk.gui.valuespec import Dictionary, Integer
def _parameter_valuespec_fireeye_mail():
return Dictionary(elements=[
(
"interval",
Integer(title="Timespan for mail rate computation",
default_value=60,
unit="minutes"),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="fireeye_mail",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_fireeye_mail,
title=lambda: _("Fireeye Mail Rate Average"),
))
(
"A Deployment enters various states during its lifecycle. Depending on this a "
"Deployment may present different conditions. You can set a time for how long "
"a condition is allowed to be in a certain state before the check alerts."
)
),
elements=[
(
"progressing",
age_levels_dropdown(_("Time until alert, if deployment not in progressing")),
),
("available", age_levels_dropdown(_("Time until alert, if deployment not available"))),
(
"replicafailure",
age_levels_dropdown(_("Time until alert, if deployment in replica failure")),
),
],
optional_keys=["progressing", "available", "replicafailure"],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="kube_deployment_conditions",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec,
title=lambda: _("Kubernetes deployment conditions"),
)
)
from cmk.gui.valuespec import Dictionary, Integer, Tuple
def _parameter_valuespec_carbon_monoxide():
return Dictionary(elements=[
(
"levels_ppm",
Tuple(
title="Levels in parts per million",
elements=[
Integer(title=_("Warning at"),
unit=_("ppm"),
default_value=10),
Integer(title=_("Critical at"),
unit=_("ppm"),
default_value=25),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="carbon_monoxide",
group=RulespecGroupCheckParametersEnvironment,
match_type="dict",
parameter_valuespec=_parameter_valuespec_carbon_monoxide,
title=lambda: _("Carbon monoxide"),
))
"failed",
Tuple(
title=_('Upper levels for "fetch failed" per second'),
elements=[
Float(title=_("Warning at"), default_value=1.0),
Float(title=_("Critical at"), default_value=2.0),
],
),
),
(
"zero",
Tuple(
title=_('Upper levels for "fetch zero length" 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_fetch",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_varnish_fetch,
title=lambda: _("Varnish Fetch"),
))
choices=bluecat_ha_operstates,
default_value=[5, 6, 7],
),
),
(
"critical",
ListChoice(
title=_("States treated as critical"),
choices=bluecat_ha_operstates,
default_value=[8, 4],
),
),
],
required_keys=["warning", "critical"],
),
),
],
required_keys=["oper_states"
], # There is only one value, so its required
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="bluecat_ha",
group=RulespecGroupCheckParametersNetworking,
match_type="dict",
parameter_valuespec=_parameter_valuespec_bluecat_ha,
title=lambda: _("Bluecat HA Settings"),
))
Tuple(
title=_("Upper levels for the number of registered desktops"),
elements=[
Integer(title=_("warning if at")),
Integer(title=_("critical if at")),
],
),
),
(
"levels_lower",
Tuple(
title=_("Lower levels for the number of registered desktops"),
elements=[
Integer(title=_("warning if below")),
Integer(title=_("critical if below")),
],
),
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="citrix_desktops_registered",
group=RulespecGroupCheckParametersApplications,
parameter_valuespec=_parameter_valuespec_plug_count,
title=lambda: _("Citrix Desktops Registered"),
)
)
),
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"),
)
)
# 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.utils import (
CheckParameterRulespecWithoutItem,
rulespec_registry,
RulespecGroupCheckParametersApplications,
)
from cmk.gui.valuespec import Integer, Tuple
def _parameter_valuespec_domino_transactions():
return Tuple(
title=_("Number of Transactions per Minute on a Lotus Domino Server"),
elements=[
Integer(title=_("warning at"), default_value=30000),
Integer(title=_("critical at"), default_value=35000),
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="domino_transactions",
group=RulespecGroupCheckParametersApplications,
parameter_valuespec=_parameter_valuespec_domino_transactions,
title=lambda: _("Lotus Domino Transactions"),
))
Tuple(
title=_("Specify levels in absolute values"),
elements=[
Integer(title=_("Warning if below"),
unit=_("MB")),
Integer(title=_("Critical if below"),
unit=_("MB")),
],
),
], ),
title=_("Levels for free memory"),
help=_(
"Specify the threshold levels for the free memory space. The free memory "
"excludes the reserved kernel memory."),
forth=lambda val: tuple(-x for x in val),
back=lambda val: tuple(-x for x in val),
),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="cisco_cpu_memory",
group=RulespecGroupCheckParametersOperatingSystem,
parameter_valuespec=_parameter_valuespec_memory,
title=lambda: _("Cisco CPU Memory"),
))
),
(
"remote_checks_failed",
MonitoringState(title=_("State when license remote check failed"),
default_value=1),
),
(
"expiration",
Tuple(
title=_("Time until license expiration"),
help=_("Remaining days until the Graylog license expires"),
elements=[
Age(title=_("Warning at"),
default_value=14 * 24 * 60 * 60),
Age(title=_("Critical at"),
default_value=7 * 24 * 60 * 60),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="graylog_license",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_graylog_license,
title=lambda: _("Graylog license"),
))
(
"auth_fails",
Tuple(
title=_(
"Authentication failures within the last 5 minutes"),
help=
_("Define levels on the number of authentication failures within the last 5 minutes."
),
elements=[
Integer(title=_("Warning at"),
unit="failures",
default_value=100),
Integer(title=_("Critical at"),
unit="failures",
default_value=200),
],
),
),
],
optional_keys=False,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="fortiauthenticator_auth_fail",
group=RulespecGroupCheckParametersNetworking,
parameter_valuespec=_parameter_valuespec_fortiauthenticator,
title=lambda: _("Fortinet FortiAuthenticator Authentication Failures"),
))
)
from cmk.gui.valuespec import Age, Dictionary, Tuple
def _parameter_valuespec_azure_ad():
return Dictionary(
elements=[
(
"age",
Tuple(
title=_("Time since last AD Connect sync"),
elements=[
Age(title=_("Warning at"), default_value=1800),
Age(title=_("Critical at"), default_value=3600),
],
),
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="azure_ad",
match_type="dict",
group=RulespecGroupCheckParametersNetworking,
parameter_valuespec=_parameter_valuespec_azure_ad,
title=lambda: _("Azure AD Connect"),
)
)
