def parameter_valuespec(self): return Dictionary(elements=[ ("ctxt", Levels( unit=_("events per second"), title=_("Context Switches"), default_levels=(1000, 5000), default_difference=(500.0, 1000.0), default_value=None, )), ("processes", Levels( unit=_("events per second"), title=_("Process Creations"), default_levels=(1000, 5000), default_difference=(500.0, 1000.0), default_value=None, )), ("pgmajfault", Levels( unit=_("events per second"), title=_("Major Page Faults"), default_levels=(1000, 5000), default_difference=(500.0, 1000.0), default_value=None, )), ], )
def _parameter_valuespec_f5_connections(): return Dictionary(elements=[ ("conns", Levels(title=_("Max. number of connections"), default_value=None, default_levels=(25000, 30000))), ("ssl_conns", Levels(title=_("Max. number of SSL connections"), default_value=None, default_levels=(25000, 30000))), ("connections_rate", Levels(title=_("Maximum connections per second"), default_value=None, default_levels=(500, 1000))), ("connections_rate_lower", Tuple( title=_("Minimum connections per second"), elements=[ Integer(title=_("Warning at")), Integer(title=_("Critical at")), ], )), ("http_req_rate", Levels(title=_("HTTP requests per second"), default_value=None, default_levels=(500, 1000))), ], )
def _parameter_valuespec_checkpoint_vsx_packets(): return Dictionary(elements=[ ("packets", Levels(title=_("Maximum rate for total number of packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec")), ("packets_accepted", Levels(title=_("Maximum rate of accepted packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec")), ("packets_rejected", Levels(title=_("Maximum rate of rejected packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec")), ("packets_dropped", Levels(title=_("Maximum rate of dropped packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec")), ("packets_logged", Levels(title=_("Maximum rate of sent logs"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec")), ], )
def _parameter_valuespec_checkpoint_vsx_traffic(): return Dictionary(elements=[ ( "bytes_accepted", Levels( title=_("Maximum rate of bytes accepted"), default_value=None, default_levels=(100000, 200000), unit="bytes/sec", ), ), ( "bytes_dropped", Levels( title=_("Maximum rate of bytes dropped"), default_value=None, default_levels=(100000, 200000), unit="bytes/sec", ), ), ( "bytes_rejected", Levels( title=_("Maximum rate of bytes rejected"), default_value=None, default_levels=(100000, 200000), unit="bytes/sec", ), ), ], )
def _parameter_valuespec_kernel_performance(): return Dictionary(elements=[ ("ctxt", Levels( unit=_("events per second"), title=_("Context Switches"), default_levels=(1000, 5000), default_difference=(500.0, 1000.0), default_value=None, )), ("processes", Levels( unit=_("events per second"), title=_("Process Creations"), default_levels=(1000, 5000), default_difference=(500.0, 1000.0), default_value=None, )), ("pgmajfault", Levels( unit=_("events per second"), title=_("Major Page Faults"), default_levels=(1000, 5000), default_difference=(500.0, 1000.0), default_value=None, )), ( "page_swap_in_levels_lower", Tuple(title=_("Swap In Lower"), elements=[ Float(title=_("Swap In warning below"), unit=_("events per second")), Float(title=_("Swap In critical below"), unit=_("events per second")) ]), ), ( "page_swap_in_levels", Tuple(title=_("Swap In Upper"), elements=[ Float(title=_("Swap In warning at"), unit=_("events per second")), Float(title=_("Swap In critical at"), unit=_("events per second")) ]), ), ( "page_swap_out_levels_lower", Tuple(title=_("Swap Out Lower"), elements=[ Float(title=_("Swap Out warning below"), unit=_("events per second")), Float(title=_("Swap Out critical below"), unit=_("events per second")) ]), ), ( "page_swap_out_levels", Tuple(title=_("Swap Out Upper"), elements=[ Float(title=_("Swap Out warning at"), unit=_("events per second")), Float(title=_("Swap Out critical at"), unit=_("events per second")) ]), ), ],)
def parameter_valuespec(self): return Dictionary( title=_("Levels for transmitted and received words"), elements=[ ("fc_tx_words", Levels(title=_("Tx"), unit=_("words/s"))), ("fc_rx_words", Levels(title=_("Rx"), unit=_("words/s"))), ], )
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"))), ],)
def _parameter_valuespec_ibm_svc_total_latency(): return Dictionary(elements=[ ("read", Levels(title=_("Read latency"), unit=_("ms"), default_value=None, default_levels=(50.0, 100.0))), ("write", Levels(title=_("Write latency"), unit=_("ms"), default_value=None, default_levels=(50.0, 100.0))), ], )
def _parameter_valuespec_fcp(): return Dictionary(elements=[ ("speed", OptionalDropdownChoice( title=_("Operating speed"), help=_( "If you use this parameter then the check goes warning if the " "interface is not operating at the expected speed (e.g. it " "is working with 8Gbit/s instead of 16Gbit/s)."), choices=[ (None, _("ignore speed")), (4000000000, "4 Gbit/s"), (8000000000, "8 Gbit/s"), (16000000000, "16 Gbit/s"), ], otherlabel=_("specify manually ->"), explicit=Integer(title=_("Other speed in bits per second"), label=_("Bits per second")))), ("traffic", ListOf( CascadingDropdown( title=_("Direction"), orientation="horizontal", choices=[ ('both', _("In / Out"), vs_interface_traffic()), ('in', _("In"), vs_interface_traffic()), ('out', _("Out"), vs_interface_traffic()), ], ), title=_("Used bandwidth (minimum or maximum traffic)"), help=_( "Setting levels on the used bandwidth is optional. If you do set " "levels you might also consider using averaging."), )), ("read_latency", Levels(title=_("Read latency"), unit=_("ms"), default_value=None, default_levels=(50.0, 100.0))), ("write_latency", Levels(title=_("Write latency"), unit=_("ms"), default_value=None, default_levels=(50.0, 100.0))), ("latency", Levels(title=_("Overall latency"), unit=_("ms"), default_value=None, default_levels=(50.0, 100.0))), ], )
def _parameter_valuespec_cpu_load(): return Transform( Dictionary( elements=[( "levels", Levels( help= _("The CPU load of a system is the number of processes currently being " "in the state <u>running</u>, i.e. either they occupy a CPU or wait " "for one. The <u>load average</u> is the averaged CPU load over the last 1, " "5 or 15 minutes. The following levels will be applied on the average " "load. On Linux system the 15-minute average load is used when applying " "those levels. The configured levels are multiplied with the number of " "CPUs, so you should configure the levels based on the value you want to " 'be warned "per CPU".'), unit="per core", default_difference=(2.0, 4.0), default_levels=(5.0, 10.0), ), )], optional_keys=False, ), forth=lambda params: params if isinstance(params, dict) else {"levels": params}, )
def parameter_valuespec(self): return Dictionary(elements=[ ( "ipv4_in_blocked", Levels( title=_( "Levels for rate of incoming IPv4 packets blocked"), unit=_("pkts/s"), default_levels=(100.0, 10000.0), default_difference=(5, 8), default_value=None, ), ), ("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 "), )), ], )
def _parameter_valuespec_safenet_hsm_operstats(): return Dictionary(elements=[ ("error_rate", Tuple( title=_("Error rate"), elements=[ Float(title=_("Warning at"), default_value=0.01, unit=_("1/s")), Float(title=_("Critical at"), default_value=0.05, unit=_("1/s")), ], )), ("request_rate", Levels( title=_("Request rate"), unit=_("1/s"), default_value=None, )), ("operation_errors", Tuple( title=_("Operation errors"), help= _("Sets levels on total operation errors since last counter reset." ), elements=[ Integer(title=_("Warning at"), default_value=0), Integer(title=_("Critical at"), default_value=1), ], )), ], )
def _parameter_valuespec_brightness(): return Levels( title=_("Brightness"), unit=_("lx"), default_value=None, default_difference=(2.0, 4.0), default_levels=(50.0, 100.0), )
def parameter_valuespec(self): return Levels( help=_("This ruleset applies to several similar checks measing various kernel " "events like context switches, process creations and major page faults. " "Please create separate rules for each type of kernel counter you " "want to set levels for."), unit=_("events per second"), default_levels=(1000, 5000), default_difference=(500.0, 1000.0), default_value=None, )
def _parameter_valuespec_checkpoint_packets(): return Dictionary(elements=[ ( "accepted", Levels( title=_("Maximum Rate of Accepted Packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec", ), ), ( "rejected", Levels( title=_("Maximum Rate of Rejected Packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec", ), ), ( "dropped", Levels( title=_("Maximum Rate of Dropped Packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec", ), ), ( "logged", Levels( title=_("Maximum Rate of Logged Packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec", ), ), ], )
def _parameter_valuespec_cpu_load(): return Levels( help= _("The CPU load of a system is the number of processes currently being " "in the state <u>running</u>, i.e. either they occupy a CPU or wait " "for one. The <u>load average</u> is the averaged CPU load over the last 1, " "5 or 15 minutes. The following levels will be applied on the average " "load. On Linux system the 15-minute average load is used when applying " "those levels. The configured levels are multiplied with the number of " "CPUs, so you should configure the levels based on the value you want to " "be warned \"per CPU\"."), unit="per core", default_difference=(2.0, 4.0), default_levels=(5.0, 10.0), )
def _parameter_valuespec_f5_bigip_vserver(): return Dictionary( elements=[ ("if_in_octets", Levels( title=_("Incoming Traffic Maximum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_in_octets_lower", Levels( title=_("Incoming Traffic Minimum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_out_octets", Levels( title=_("Outgoing Traffic Maximum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_out_octets_lower", Levels( title=_("Outgoing Traffic Minimum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_total_octets", Levels( title=_("Total Traffic Maximum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_total_octets_lower", Levels( title=_("Total Traffic Minimum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_in_pkts", Levels( title=_("Incoming Packets Maximum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ("if_in_pkts_lower", Levels( title=_("Incoming Packets Minimum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ("if_out_pkts", Levels( title=_("Outgoing Packets Maximum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ("if_out_pkts_lower", Levels( title=_("Outgoing Packets Minimum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ("if_total_pkts", Levels( title=_("Total Packets Maximum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ("if_total_pkts_lower", Levels( title=_("Total Packets Minimum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ( "state", Dictionary( title=_("Map states"), elements=[ ("is_disabled", MonitoringState(title=_("Is disabled"), default_value=1)), ("is_up_and_available", MonitoringState(title=_("Is up and available"), default_value=0)), ("is_currently_not_available", MonitoringState(title=_("Is currently not available"), default_value=2)), ("is_not_available", MonitoringState(title=_("Is not available"), default_value=2)), ("availability_is_unknown", MonitoringState(title=_("Availability is unknown"), default_value=1)), ("is_unlicensed", MonitoringState(title=_("Is unlicensed"), default_value=3)), ( "children_pool_members_down_if_not_available", # Special handling, see check plugin MonitoringState(title=_( "The children pool member(s) are down if VServer is not available" ), default_value=0)), ], optional_keys=False, )), ], )
def cpu_util_elements(): return [ ("core_util_time_total", Tuple( title=_( "Levels over an extended time period on total CPU utilization" ), elements=[ Percentage(title=_("High utilization at "), default_value=100.0), Age(title=_("Warning after "), default_value=5 * 60), Age(title=_("Critical after "), default_value=15 * 60), ], help= _("With this configuration, Checkmk will alert if the actual (not averaged) total CPU is " "exceeding a utilization threshold over an extended period of time. " "ATTENTION: This configuration cannot be used for check <i>lparstat_aix.cpu_util</i>!" ))), ("core_util_time", Tuple( title= _("Levels over an extended time period on a single core CPU utilization" ), elements=[ Percentage( title=_("High utilization at "), default_value=100.0), Age(title=_("Warning after "), default_value=5 * 60), Age(title=_("Critical after "), default_value=15 * 60), ], help= _("A single thread fully utilizing a single core (potentially due to a bug) " "may go unnoticed when only monitoring the total utilization of the CPU. " "With this configuration, Checkmk will alert if a single core is " "exceeding a utilization threshold over an extended period of time." "This is currently only supported on linux and windows agents " "as well as devices monitored through the host-resource mib"))), ("average", Integer( title=_("Averaging for total CPU utilization"), help= _("When this option is activated then the CPU utilization is being " "averaged <b>before</b> the levels on total CPU utilization are being applied." ), unit=_("minutes"), minvalue=1, default_value=15, label=_("Compute average over last "), )), ("average_single", Dictionary( title=_("Averaging for single cores"), help= _("Compute averaged single-core CPU utilizations. Note that this option only has " "an effect if at least one of the sub-options 'Apply single-core levels' or " "'Graphs for averaged single-core utilizations' is enabled."), elements=[ ("time_average", Integer( title=_("Time frame"), unit=_("minutes"), minvalue=1, default_value=15, label=_("Compute average over last "), )), ("apply_levels", DropdownChoice( title= _("Apply single-core levels defined in 'Levels on single cores'" ), help=_( "Apply the levels for single cores to the averaged instead of the " "instantaneous utilizations."), choices=[ (True, _("Enable")), (False, _("Disable")), ], default_value=False, )), ("show_graph", DropdownChoice( title=_("Graphs for averaged single-core utilizations"), help=_( "Create a separate graph showing the averaged single-core CPU " "utilizations."), choices=[ (True, _("Enable")), (False, _("Disable")), ], default_value=False, )), ], optional_keys=False, )), ("util", Levels( title=_("Levels on total CPU utilization"), unit="%", default_levels=(90, 95), default_difference=(5, 8), default_value=None, help= _("The CPU utilization sums up the percentages of CPU time that is used " "for user processes, kernel routines (system), disk wait (sometimes also " "called IO wait) or nothing (idle). The levels are always applied " "on the average utilization since the last check - which is usually one minute." ), )), ("levels_single", Tuple( title=_("Levels on single cores"), elements=[ Percentage(title=_("Warning at"), default_value=90.0), Percentage(title=_("Critical at"), default_value=95.0) ], help= _("Here you can set levels on the CPU utilization on single cores" ), )), ("core_util_graph", DropdownChoice( title=_("Graphs for individual cores"), help=_( "This adds another graph to the performance CPU utilization " "details page, showing utilization of individual cores. " "Please note that this graph may be impractical on " "device with very many cores. " "This is currently only supported on linux and windows agents " "as well as devices monitored through the host-resource mib"), choices=[ (True, _("Enable")), (False, _("Disable")), ], default_value=True, )), ]
def _parameter_valuespec_disk_io(): return Dictionary(elements=[ ("read", Levels(title=_("Read throughput"), unit=_("MB/s"), default_value=None, default_levels=(50.0, 100.0))), ("write", Levels(title=_("Write throughput"), unit=_("MB/s"), default_value=None, default_levels=(50.0, 100.0))), ("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."), default_value=5, minvalue=1, unit=_("minutes"))), ("latency", Tuple( title=_("IO Latency"), elements=[ Float(title=_("warning at"), unit=_("ms"), default_value=80.0), Float(title=_("critical at"), unit=_("ms"), default_value=160.0), ], )), ( "latency_perfdata", Checkbox(title=_("Performance Data for Latency"), label=_("Collect performance data for disk latency"), help=_("Note: enabling performance data for the latency might " "cause incompatibilities with existing historical data " "if you are running PNP4Nagios in SINGLE mode.")), ), ("read_ql", Tuple( title=_("Read Queue-Length"), elements=[ Float(title=_("warning at"), default_value=80.0), Float(title=_("critical at"), default_value=90.0), ], )), ("write_ql", Tuple( title=_("Write Queue-Length"), elements=[ Float(title=_("warning at"), default_value=80.0), Float(title=_("critical at"), default_value=90.0), ], )), ( "ql_perfdata", Checkbox(title=_("Performance Data for Queue Length"), label=_("Collect performance data for disk latency"), help=_("Note: enabling performance data for the latency might " "cause incompatibilities with existing historical data " "if you are running PNP4Nagios in SINGLE mode.")), ), ("read_ios", Levels( title=_("Read operations"), unit=_("1/s"), default_levels=(400.0, 600.0), )), ("write_ios", Levels( title=_("Write operations"), unit=_("1/s"), default_levels=(300.0, 400.0), )), ],)
def parameter_valuespec(self): return Levels( title=_(u"NTLS Links"), default_value=None, )
def _parameter_valuespec_diskstat(): return Dictionary( help= _("With this rule you can set limits for various disk IO statistics. " "Keep in mind that not all of these settings may be applicable for the actual " "check. For example, if the check doesn't provide a <i>Read wait</i> information in its " "output, any configuration setting referring to <i>Read wait</i> will have no effect." ), elements=[ ("read", Levels( title=_("Read throughput"), unit=_("MB/s"), default_levels=(50.0, 100.0), )), ("write", Levels( title=_("Write throughput"), unit=_("MB/s"), default_levels=(50.0, 100.0), )), ("utilization", Levels( title=_("Disk Utilization"), unit=_("%"), default_levels=(80.0, 90.0), )), ("latency", Levels( title=_("Disk Latency"), unit=_("ms"), default_levels=(80.0, 160.0), )), ("read_latency", Levels( title=_("Disk Read Latency"), unit=_("ms"), default_levels=(80.0, 160.0), )), ("write_latency", Levels( title=_("Disk Write Latency"), unit=_("ms"), default_levels=(80.0, 160.0), )), ("read_wait", Levels(title=_("Read wait"), unit=_("ms"), default_levels=(30.0, 50.0))), ("write_wait", Levels(title=_("Write wait"), unit=_("ms"), default_levels=(30.0, 50.0))), ("average", Age( title=_("Averaging"), help= _("When averaging is set, then all of the disk's metrics are averaged " "over the selected interval - rather then the check interval. This allows " "you to make your monitoring less reactive to short peaks. But it will also " "introduce a loss of accuracy in your graphs. "), default_value=300, )), ("read_ios", Levels(title=_("Read operations"), unit=_("1/s"), default_levels=(400.0, 600.0))), ("write_ios", Levels(title=_("Write operations"), unit=_("1/s"), default_levels=(300.0, 400.0))), ], )
def _parameter_valuespec_safenet_ntls_links(): return Levels( title=_("NTLS Links"), default_value=None, )
def _parameter_valuespec_f5_bigip_snat(): return Dictionary(elements=[("if_in_octets", Levels( title=_("Incoming Traffic Maximum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_in_octets_lower", Levels( title=_("Incoming Traffic Minimum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_out_octets", Levels( title=_("Outgoing Traffic Maximum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_out_octets_lower", Levels( title=_("Outgoing Traffic Minimum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_total_octets", Levels( title=_("Total Traffic Maximum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_total_octets_lower", Levels( title=_("Total Traffic Minimum"), unit=_("bytes/s"), default_difference=(5, 8), default_value=None, )), ("if_in_pkts", Levels( title=_("Incoming Packets Maximum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ("if_in_pkts_lower", Levels( title=_("Incoming Packets Minimum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ("if_out_pkts", Levels( title=_("Outgoing Packets Maximum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ("if_out_pkts_lower", Levels( title=_("Outgoing Packets Minimum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ("if_total_pkts", Levels( title=_("Total Packets Maximum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, )), ("if_total_pkts_lower", Levels( title=_("Total Packets Minimum"), unit=_("packets/s"), default_difference=(5, 8), default_value=None, ))], )
MonitoringState, TextAscii, ) from cmk.gui.plugins.wato import ( RulespecGroupCheckParametersNetworking, register_check_parameters, Levels, ) register_check_parameters( RulespecGroupCheckParametersNetworking, "checkpoint_packets", _("Checkpoint Firewall Packet Rates"), Dictionary(elements=[ ("accepted", Levels(title=_("Maximum Rate of Accepted Packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec")), ("rejected", Levels(title=_("Maximum Rate of Rejected Packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec")), ("dropped", Levels(title=_("Maximum Rate of Dropped Packets"), default_value=None, default_levels=(100000, 200000), unit="pkts/sec")), ("logged", Levels(title=_("Maximum Rate of Logged Packets"), default_value=None, default_levels=(100000, 200000),
def parameter_valuespec(self): return Levels( title=_(u"NTLS Clients"), help=_(u"Number of connected clients"), default_value=None, )
def _parameter_valuespec_safenet_ntls_clients(): return Levels( title=_("NTLS Clients"), help=_("Number of connected clients"), default_value=None, )
_("When this option is activated then the CPU utilization is being " "averaged <b>before</b> the levels on total CPU utilization are being applied." ), unit=_("minutes"), minvalue=1, default_value=15, label=_("Compute average over last "), )), ("util", Levels( title=_("Levels on total CPU utilization"), unit="%", default_levels=(90, 95), default_difference=(5, 8), default_value=None, help= _("The CPU utilization sums up the percentages of CPU time that is used " "for user processes, kernel routines (system), disk wait (sometimes also " "called IO wait) or nothing (idle). The levels are always applied " "on the average utilization since the last check - which is usually one minute." ), )), ("levels_single", Tuple( title=_("Levels on single cores"), elements=[ Percentage(title=_("Warning at"), default_value=90.0), Percentage(title=_("Critical at"), default_value=95.0) ], help= _("Here you can set levels on the CPU utilization on single cores"