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"