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"), ) )