elements=[
Integer(
title=_("Warning at"),
minvalue=0,
default_value=40000,
unit=_("connections"),
),
Integer(
title=_("Critical at"),
minvalue=0,
default_value=50000,
unit=_("connections"),
),
],
),
),
],
optional_keys=False,
),
forth=lambda x: x if isinstance(x, dict) else {"levels": x},
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="checkpoint_connections",
group=RulespecGroupCheckParametersApplications,
parameter_valuespec=_parameter_valuespec_checkpoint_connections,
title=lambda: _("Checkpoint Firewall Connections"),
))
),
Tuple(
title=_("Specify levels"),
elements=[
Integer(
title=_("Warning below"),
minvalue=-1,
unit=_("online canisters"),
),
Integer(
title=_("Critical below"),
minvalue=-1,
unit=_("online canisters"),
),
],
),
],
),
)], )
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="ibm_svc_enclosure",
group=RulespecGroupCheckParametersStorage,
item_spec=_item_spec_ibm_svc_enclosure,
match_type="dict",
parameter_valuespec=_parameter_valuespec_ibm_svc_enclosure,
title=lambda: _("IBM SVC Enclosure"),
))
elements=[
(
"levels",
Tuple(
title=_("Upper limits in percent"),
elements=[
Percentage(title=_("Warning at"),
allow_int=True,
default_value=1),
Percentage(title=_("Critical at"),
allow_int=True,
default_value=5),
],
),
),
],
),
forth=_transform_smoke_detection_params,
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="smoke",
group=RulespecGroupCheckParametersEnvironment,
item_spec=lambda: TextInput(title=_("Sensor ID"),
help=_("The identifier of the sensor.")),
parameter_valuespec=_parameter_valuespec_smoke,
title=lambda: _("Smoke Detection"),
))
"min",
Tuple(
title=_("Minimum required uptime"),
elements=[
Age(title=_("Warning if below")),
Age(title=_("Critical if below")),
],
),
),
(
"max",
Tuple(
title=_("Maximum allowed uptime"),
elements=[
Age(title=_("Warning at")),
Age(title=_("Critical at")),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="uptime",
group=RulespecGroupCheckParametersOperatingSystem,
match_type="dict",
parameter_valuespec=_parameter_valuespec_uptime,
title=lambda: _("Uptime since last reboot"),
))
def _parameter_valuespec_jvm_threading():
return Dictionary(elements=[
(
"threadcount_levels",
Levels(
title=_("Maximal number of threads"),
default_value=None,
),
),
(
"threadrate_levels",
Levels(
title=_("Maximal rate of thread count"),
default_value=None,
),
),
("daemonthreadcount_levels",
Levels(title=_("Maximal number of daemon threads"))),
], )
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="jvm_threading",
group=RulespecGroupCheckParametersApplications,
item_spec=_item_spec_jvm_threading,
parameter_valuespec=_parameter_valuespec_jvm_threading,
title=lambda: _("JVM threading"),
))
orientation="horizontal",
elements=[
Integer(
title=_("Nodes"),
help=
_("Apply these levels to clusters that have at least the following number of nodes:"
),
minvalue=1,
),
Dictionary(elements=_esx_host_memory_elements()),
],
),
title=_("Clusters: node specific memory utilization"),
help=_(
"Configure thresholds that apply to clusters based on how many nodes "
"they have."),
),
),
], ),
forth=_transform_memory_usage_params,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="esx_host_memory",
group=RulespecGroupCheckParametersOperatingSystem,
parameter_valuespec=_parameter_valuespec_esx_host_memory,
title=lambda: _("Main memory usage of ESX host system"),
))
choices=bluecat_operstates,
default_value=[2, 3, 4],
),
),
(
"critical",
ListChoice(
title=_("States treated as critical"),
choices=bluecat_operstates,
default_value=[5],
),
),
],
required_keys=["warning", "critical"],
),
),
],
required_keys=["oper_states"], # There is only one value, so its required
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="bluecat_command_server",
group=RulespecGroupCheckParametersNetworking,
match_type="dict",
parameter_valuespec=_parameter_valuespec_bluecat_command_server,
title=lambda: _("Bluecat Command Server Settings"),
)
)
rulespec_registry,
RulespecGroupCheckParametersStorage,
)
from cmk.gui.valuespec import Age, Dictionary, TextInput, Tuple
def _parameter_valuespec_emcvnx_storage_pools_tiering():
return Dictionary(elements=[
(
"time_to_complete",
Tuple(
title=_("Upper levels for estimated time to complete"),
elements=[
Age(title=_("Warning at"), default_value=300 * 60 * 60),
Age(title=_("Critical at"), default_value=350 * 60 * 60),
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="emcvnx_storage_pools_tiering",
group=RulespecGroupCheckParametersStorage,
item_spec=lambda: TextInput(title=_("Pool name")),
match_type="dict",
parameter_valuespec=_parameter_valuespec_emcvnx_storage_pools_tiering,
title=lambda: _("EMC VNX storage pools tiering"),
))
from cmk.gui.valuespec import Dictionary, Integer, Tuple
def _parameter_valuespec_lsnat():
return Dictionary(
elements=[
(
"current_bindings",
Tuple(
title=_("Number of current LSNAT bindings"),
elements=[
Integer(title=_("Warning at"), size=10, unit=_("bindings")),
Integer(title=_("Critical at"), size=10, unit=_("bindings")),
],
),
),
],
optional_keys=False,
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="lsnat",
group=RulespecGroupCheckParametersNetworking,
match_type="dict",
parameter_valuespec=_parameter_valuespec_lsnat,
title=lambda: _("Enterasys LSNAT Bindings"),
)
)
elements=[
Float(title=_("Warning below"), unit="1/s"),
Float(title=_("Critical below"), unit="1/s"),
],
),
),
(
"abs_memory",
Tuple(
title=_("Absolute levels for used memory"),
elements=[
Filesize(title=_("Warning at")),
Filesize(title=_("Critical at")),
],
),
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="rabbitmq_queues",
group=RulespecGroupCheckParametersApplications,
item_spec=lambda: TextInput(title=_("Queue name")),
match_type="dict",
parameter_valuespec=_parameter_valuespec_rabbitmq_queues,
title=lambda: _("RabbitMQ queues"),
)
)
from cmk.gui.valuespec import Dictionary, MonitoringState
def _parameter_valuespec_apt():
return Dictionary(elements=[
(
"normal",
MonitoringState(
title=_("State when normal updates are pending"),
default_value=1,
),
),
(
"security",
MonitoringState(
title=_("State when security updates are pending"),
default_value=2,
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="apt",
group=RulespecGroupCheckParametersOperatingSystem,
match_type="dict",
parameter_valuespec=_parameter_valuespec_apt,
title=lambda: _("APT Updates"),
))
default_value=0)),
("offline",
MonitoringState(title=_("Device offline"),
default_value=2)),
(
"going online",
MonitoringState(title=_("Device going online"),
default_value=1),
),
(
"state not available",
MonitoringState(title=_("Device state not available"),
default_value=3),
),
],
title=_("Map Device States"),
optional_keys=[],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="quantum_storage_status",
group=RulespecGroupCheckParametersStorage,
match_type="dict",
parameter_valuespec=_parameter_valuespec_quantum_storage_status,
title=lambda: _("Quantum Storage Status"),
))
from cmk.gui.valuespec import Age, Dictionary, Tuple
def _parameter_valuespec_mssql_counters_ple():
return Dictionary(
help=_("This check monitors MSSQL page life expectancies."),
elements=[
(
"mssql_min_page_life_expectancy",
Tuple(
title=_("Minimum Page Life Expectancy"),
elements=[
Age(title=_("Warning below")),
Age(title=_("Critical below")),
],
),
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="mssql_counters_page_life_expectancy",
group=RulespecGroupCheckParametersApplications,
item_spec=mssql_item_spec_instance_tablespace,
match_type="dict",
parameter_valuespec=_parameter_valuespec_mssql_counters_ple,
title=lambda: _("MSSQL Page Life Expectancy"),
))
_DEFAULT_DATADOG_AND_CHECKMK_STATES
],
rows=len(_DEFAULT_DATADOG_AND_CHECKMK_STATES) + 2,
size=50,
),
),
],
title=_("Discovery of Datadog monitors"),
optional_keys=False,
)
rulespec_registry.register(
HostRulespec(
group=RulespecGroupCheckParametersDiscovery,
match_type="dict",
name="datadog_monitors_discovery",
valuespec=_valuespec_datadog_monitors_discovery,
), )
def _item_spec_datadog_monitors():
return TextInput(
title=_("Datadog monitor"),
help=_("The name of the Datadog monitor."),
)
def _parameter_valuespec_datadog_monitors() -> Dictionary:
return Dictionary([
(
("primary",
_("require primary interface to be active")),
("lowest",
_("require interface that sorts lowest alphabetically"
)),
],
default_value="ignore",
),
),
(
"ieee_302_3ad_agg_id_missmatch_state",
MonitoringState(
title=_("State for missmatching Aggregator IDs for LACP"),
default_value=1,
),
),
],
ignored_keys=["primary"],
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="bonding",
group=RulespecGroupCheckParametersNetworking,
item_spec=lambda: TextInput(title=_("Name of the bonding interface")),
match_type="dict",
parameter_valuespec=_parameter_valuespec_bonding,
title=lambda: _("Linux bonding interface status"),
))
"errors",
Tuple(
title=_('Upper levels for "ESI errors" per second'),
elements=[
Float(title=_("Warning at"), default_value=1.0),
Float(title=_("Critical at"), default_value=2.0),
],
),
),
(
"warnings",
Tuple(
title=_('Upper levels for "ESI warnings" 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_esi",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec_varnish_esi,
title=lambda: _("Varnish ESI"),
))
Tuple(
title=_("Averaged values lower level"),
elements=[
Float(title=_("Warning below")),
Float(title=_("Critical below"))
],
),
),
(
"custom_svc_avg_upper",
Tuple(
title=_("Averaged values upper level"),
elements=[
Float(title=_("Warning at")),
Float(title=_("Critical at"))
],
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="jira_custom_svc",
group=RulespecGroupCheckParametersApplications,
item_spec=lambda: TextInput(title=_("Custom service name"), ),
match_type="dict",
parameter_valuespec=_parameter_valuespec_jira_custom_svc,
title=lambda: _("Jira custom service"),
))
),
),
(
"average",
Integer(
title=_("Averaging"),
help=_(
"When this option is activated then the block rate is being "
"averaged <b>before</b> the levels are being applied."
),
unit=_("minutes"),
default_value=3,
minvalue=1,
label=_("Compute average over last "),
),
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="firewall_if",
group=RulespecGroupCheckParametersApplications,
item_spec=_item_spec_firewall_if,
match_type="dict",
parameter_valuespec=_parameter_valuespec_firewall_if,
title=lambda: _("Firewall Interfaces"),
)
)
("unknown", 3),
]
def _parameter_valuespec_emc_datadomain_mtree() -> Dictionary:
return Dictionary(
title=_("Mapping of MTree state to monitoring state"),
help=
_("Define a translation of the possible states of the MTree to monitoring "
"states, i.e. to the result of the check. This overwrites the default "
"mapping used by the check."),
elements=[(
state,
MonitoringState(
title=_("Monitoring state if MTree state is '%s'") % state,
default_value=check_res,
),
) for state, check_res in STATES_CHECK_RES],
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="emc_datadomain_mtree",
group=RulespecGroupCheckParametersStorage,
item_spec=lambda: TextInput(title=_("MTree name")),
match_type="dict",
parameter_valuespec=_parameter_valuespec_emc_datadomain_mtree,
title=lambda: _("EMC Data Domain MTree state"),
))
Percentage(title=_("Critical if below")),
],
),
),
(
"max_capacity",
Tuple(
title=_("Maximal free cooling positions"),
elements=[
Percentage(title=_("Warning if above")),
Percentage(title=_("Critical if above")),
],
),
),
],
help=_(
"Here you can set different warn/crit levels regarding the free cooling "
" positions."),
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="liebert_cooling_position",
group=RulespecGroupCheckParametersEnvironment,
item_spec=_item_spec_cooling_pos,
match_type="dict",
parameter_valuespec=_parameter_valuespec_cooling_pos,
title=lambda: _("Percentage of free cooling positions"),
))
def _valuespec_datasource_programs():
return TextInput(
title=_("Individual program call instead of agent access"),
help=_(
"For agent based checks Check_MK allows you to specify an alternative "
"program that should be called by Check_MK instead of connecting the agent "
"via TCP. That program must output the agent's data on standard output in "
"the same format the agent would do. This is for example useful for monitoring "
"via SSH."
)
+ monitoring_macro_help()
+ _('This option can only be used with the permission "Can add or modify executables".')
+ _(
"<br> HINT: The individual program is called from the current working directory. "
"You should therefore specify absolute path names in scripts (by using environment variables like OMD_SITE) "
"to make the individual program call run correctly in all execution contexts (UI and console)."
),
label=_("Command line to execute"),
empty_text=_("Access Checkmk Agent via TCP"),
size=80,
)
rulespec_registry.register(
HostRulespec(
group=RulespecGroupDatasourceProgramsCustom,
name="datasource_programs",
valuespec=_valuespec_datasource_programs,
)
)
(
"running",
Tuple(
title=_("Number of currently running sessions"),
help=
_("Levels for the number of sessions that are currently active"
),
elements=[
Integer(title=_("Warning at"),
unit=_("sessions"),
default_value=10),
Integer(title=_("Critical at"),
unit=_("sessions"),
default_value=20),
],
),
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="postgres_instance_sessions",
group=RulespecGroupCheckParametersApplications,
item_spec=lambda: TextInput(title=_("Instance")),
match_type="dict",
parameter_valuespec=_parameter_valuespec_postgres_instance_sessions,
title=lambda: _("PostgreSQL Sessions"),
))
Float(title=_("critical at"), unit=_("MB/s")),
],
),
),
(
"average",
Integer(
title=_("Average"),
help=
_("When averaging is set, a floating average value "
"of the disk throughput is computed and the levels for read "
"and write will be applied to the average instead of the current "
"value."),
minvalue=1,
default_value=5,
unit=_("minutes"),
),
),
], )
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="mysql_innodb_io",
group=RulespecGroupCheckParametersApplications,
item_spec=_item_spec_mysql_innodb_io,
match_type="dict",
parameter_valuespec=_parameter_valuespec_mysql_innodb_io,
title=lambda: _("MySQL InnoDB Throughput"),
))
("delete", _("Delete")),
("open", _("Open")),
("modify", _("Modify")),
("access", _("Access")),
("movedfrom", _("Moved from")),
("movedto", _("Moved to")),
("moveself", _("Move self")),
],
),
Age(title=_("Warning at")),
Age(title=_("Critical at")),
], ),
title=_("Age of last operation"),
movable=False,
),
),
],
optional_keys=False,
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="inotify",
group=RulespecGroupCheckParametersStorage,
item_spec=_item_spec_inotify,
match_type="dict",
parameter_valuespec=_parameter_valuespec_inotify,
title=lambda: _("INotify Levels"),
))
(
"values",
ListOf(
valuespec=Tuple(
elements=_special_agents_siemens_plc_siemens_plc_value(
),
orientation="horizontal",
),
title=_("Values to fetch from all devices"),
validate=
_special_agents_siemens_plc_validate_siemens_plc_values,
),
),
],
optional_keys=["timeout"],
title=_("Siemens PLC (SPS)"),
help=
_("This rule selects the Siemens PLC agent instead of the normal Check_MK Agent "
"and allows monitoring of Siemens PLC using the Snap7 API. You can configure "
"your connection settings and values to fetch here."),
)
rulespec_registry.register(
HostRulespec(
factory_default=_factory_default_special_agents_siemens_plc(),
group=RulespecGroupDatasourceProgramsHardware,
name="special_agents:siemens_plc",
valuespec=_valuespec_special_agents_siemens_plc,
))
_("Other keywords for this rule: %s") % "Tomcat, Jolokia, JMX"),
elements=sum(
(_get_memory_level_elements(mem_type)
for mem_type in ("heap", "nonheap", "total")),
[],
),
),
forth=_transform_legacy_parameters_jvm_memory,
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="jvm_memory",
group=RulespecGroupCheckParametersApplications,
item_spec=_item_spec_jvm_memory,
match_type="dict",
parameter_valuespec=_parameter_valuespec_jvm_memory,
title=lambda: _("JVM memory levels"),
))
def _item_spec_jvm_memory_pools() -> TextInput:
return TextInput(
title=_("Name of the memory pool"),
help=
_("The name of the memory pool in the format 'INSTANCE Memory Pool POOLNAME'"
),
allow_empty=False,
)
"pidpressure",
MonitoringState(
title=_(
"Monitoring state if the PIDPRESSURE condition is faulty or not available"
),
default_value=2,
),
),
(
"networkunavailable",
MonitoringState(
title=_(
"Monitoring state if the NETWORKUNAVAILABLE condition is faulty or not available"
),
default_value=2,
),
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithoutItem(
check_group_name="kube_node_conditions",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_parameter_valuespec,
title=lambda: _("Node conditions"),
)
)
),
),
(
"map_frozen",
Dictionary(
title=_("Map Attribute 'Frozen'"),
elements=[
(
"tfrozen",
MonitoringState(title=_("Temporarily frozen"), default_value=1),
),
("frozen", MonitoringState(title=_("Frozen"), default_value=2)),
],
optional_keys=False,
),
),
],
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="veritas_vcs",
group=RulespecGroupCheckParametersApplications,
item_spec=lambda: TextInput(title=_("Cluster Name")),
match_type="dict",
parameter_valuespec=_parameter_valuespec_veritas_vcs,
title=lambda: _("Veritas Cluster Server"),
)
)
),
(
"summarize_transactionlogs",
Checkbox(
title=_("Display only a summary of all Transactionlogs"),
label=_("Summarize Transactionlogs"),
),
),
],
optional_keys=[],
)
rulespec_registry.register(
HostRulespec(
group=RulespecGroupCheckParametersDiscovery,
name="mssql_transactionlogs_discovery",
valuespec=_valuespec_mssql_transactionlogs_discovery,
))
def _parameter_valuespec_mssql_transactionlogs():
return Dictionary(
title=_("File Size Levels"),
help=
_("Specify levels for transactionlogs of a database. Please note that relative "
"levels will only work if there is a max_size set for the file on the database "
"side."),
elements=[
("used_levels",
levels_absolute_or_dynamic(_("Transactionlog"), _("used"))),
(
# the check plugin. Please do not change them.
def _vs_gcs_bucket_requests() -> ValueSpec:
return Dictionary(
title=_("Parameters for the bucket requests"),
elements=[("requests",
Levels(title=_("Parameters for the bucket requests"),
unit="1/second"))],
)
rulespec_registry.register(
CheckParameterRulespecWithItem(
check_group_name="gcp_gcs_requests",
group=RulespecGroupCheckParametersApplications,
match_type="dict",
parameter_valuespec=_vs_gcs_bucket_requests,
title=lambda: _("GCP/GCS Requests"),
))
def _vs_gcs_bucket_network() -> ValueSpec:
return Dictionary(
title=_("Parameters for the bucket network io"),
elements=[
("net_data_sent",
Levels(title=_("Parameters send bytes"), unit="bytes/s")),
("net_data_recv",
Levels(title=_("Parameters received bytes"), unit="bytes/s")),
],
)
