def check_huawei_storage_hwcache(item, params, section) -> CheckResult: for id, ru, wu, mwu, hr in section: if item == id: yield Result(state=State.OK, summary="HWCache %s: ok" % item) yield Metric("read_utilization", int(ru)) yield Metric("write_utilization", int(wu)) yield Metric("mirror_write_utilization", int(mwu)) yield Metric("hit_ratio", int(hr))
def test_check_disk(): with pytest.raises(IgnoreResultsError): list(aix_diskiod._check_disk({}, DISK)) assert list(aix_diskiod._check_disk({}, DISK)) == [ Result(state=state.OK, summary="Read: 0.00 B/s"), Metric("disk_read_throughput", 0.0), Result(state=state.OK, summary="Write: 0.00 B/s"), Metric("disk_write_throughput", 0.0), ]
def test_check_disk(value_store): with pytest.raises(IgnoreResultsError): list(aix_diskiod._check_disk({}, DISK)) assert list(aix_diskiod._check_disk({}, DISK)) == [ Result(state=state.OK, summary='Read: 0.00 B/s'), Metric('disk_read_throughput', 0.0), Result(state=state.OK, summary='Write: 0.00 B/s'), Metric('disk_write_throughput', 0.0), ]
def test_check() -> None: section = parse_ruckus_spot_ap(STRING_TABLE) params = {"levels_drifted": (0, 1), "levels_not_responding": (2, 3)} assert [*check_ruckus_spot_ap("5 GHz", params, section)] == [ Result(state=State.OK, summary="Devices: 2"), Metric("ap_devices_total", 2.0), Result(state=State.WARN, summary="Drifted: 0 (warn/crit at 0/1)"), Metric("ap_devices_drifted", 0.0, levels=(0.0, 1.0)), Result(state=State.OK, notice="Not responding: 1"), Metric("ap_devices_not_responding", 1.0, levels=(2.0, 3.0)), ]
def test_check_fast_lta_volumes(check_fast_lta_volumes) -> None: assert list(check_fast_lta_volumes("Archiv_Test", {}, parsed)) == [ Result(state=State.OK, summary="1.0% used (9.31 of 931.32 GB)"), Metric( "fs_used", 9536.7431640625, levels=(762939.453125, 858306.884765625), boundaries=(0.0, 953674.31640625), ), Metric("fs_size", 953674.31640625), Metric("fs_used_percent", 1.0), ]
def test_check_k8s_node_count_default_params() -> None: result = list( check(check_default_parameters, NodeCount(worker=0, control_plane=0))) assert result == [ Result(state=State.CRIT, summary="Number of worker nodes: 0 (warn/crit below 3/1)"), Metric("k8s_node_count_worker", 0.0, boundaries=(0.0, None)), Result( state=State.CRIT, summary="Number of control plane nodes: 0 (warn/crit below 3/1)"), Metric("k8s_node_count_control_plane", 0.0, boundaries=(0.0, None)), ]
def test_check_fast_lta_silent_cube_capacity( check_fast_lta_silent_cubes_capacity) -> None: assert list(check_fast_lta_silent_cubes_capacity(None, {}, info)) == [ Result(state=State.OK, summary="48.43% used (3.52 of 7.28 TB)"), Metric("fs_used", 3695972.90234375, levels=(6104729.6, 6867820.8), boundaries=(0.0, 7630912.0)), Metric("fs_size", 7630912.0), Metric("fs_used_percent", 48.4342225718728), ]
def test_check_ps_common_cpu(data): def time_info(service, agent_info, check_time, cputime, cpu_cores): with on_time(datetime.datetime.utcfromtimestamp(check_time), "CET"): _cpu_info, parsed_lines = ps_section.parse_ps( splitter(agent_info.format(cputime))) lines_with_node_name: List[Tuple[Optional[str], ps_utils.PsInfo, List[str]]] = [ (None, ps_info, cmd_line) for (ps_info, cmd_line) in parsed_lines ] return list( ps_utils.check_ps_common( label="Processes", item=service.item, params=service.parameters, # type: ignore[arg-type] process_lines=lines_with_node_name, cpu_cores=cpu_cores, total_ram_map={}, )) rescale_params = ({ "cpu_rescale_max": data.cpu_rescale_max } if data.cpu_rescale_max is not None else {}) service = Service( item="test", parameters={ "process": "~test", "user": None, "levels": (1, 1, 99999, 99999), # from factory defaults **rescale_params, }, ) # Initialize counters time_info(service, data.agent_info, 0, 0, data.cpu_cores) # Check_cpu_utilization output = time_info(service, data.agent_info, 60, data.cputime, data.cpu_cores) assert output[:6] == [ Result(state=state.OK, summary="Processes: 1"), Metric("count", 1, levels=(100000, 100000), boundaries=(0, None)), Result(state=state.OK, summary="virtual: 105 KiB"), Metric("vsz", 105), Result(state=state.OK, summary="physical: 30.0 KiB"), Metric("rss", 30), ] assert output[8:] == [ Result(state=state.OK, summary="Running for: 3 hours 59 minutes"), ]
def fixture_fetcher_checker_counters_list(): return [ Result(state=state.OK, notice="Fetcher helper usage: 0%"), Metric("helper_usage_fetcher", 0.0, levels=(80.0, 90.0), boundaries=(0.0, None)), Result(state=state.OK, notice="Checker helper usage: 0%"), Metric("helper_usage_checker", 0.0, levels=(80.0, 90.0), boundaries=(0.0, None)), ]
def test_check_disk(): value_store: dict[str, Any] = {} now = 1647029464.27418 with pytest.raises(IgnoreResultsError): list(aix_diskiod._check_disk({}, DISK, value_store, now)) assert list(aix_diskiod._check_disk({}, DISK, value_store, now + 60)) == [ Result(state=state.OK, summary="Read: 0.00 B/s"), Metric("disk_read_throughput", 0.0), Result(state=state.OK, summary="Write: 0.00 B/s"), Metric("disk_write_throughput", 0.0), ]
def test_docker_container_diskstat( fix_register, section_name: str, plugin_name: str, string_table_0, string_table_10, read_bytes, write_bytes, read_ops, write_ops, ) -> None: agent_section = fix_register.agent_sections[SectionName(section_name)] plugin = fix_register.check_plugins[CheckPluginName(plugin_name)] section_0_seconds = agent_section.parse_function(string_table_0) section_60_seconds = agent_section.parse_function(string_table_10) with pytest.raises(IgnoreResultsError): # first run, no rate metrics yet: _ = list( plugin.check_function( params={}, section_multipath=None, section_diskstat=section_0_seconds, item="SUMMARY", )) # now we have a rate: result = list( plugin.check_function( params={}, section_multipath=None, section_diskstat=section_60_seconds, item="SUMMARY", )) expected_result = [ Result(state=State.OK, summary=f"Read: {iobandwidth(read_bytes)}"), Metric("disk_read_throughput", read_bytes), Result(state=State.OK, summary=f"Write: {iobandwidth(write_bytes)}"), Metric("disk_write_throughput", write_bytes), ] if write_ops != 0 and read_ops != 0: expected_result += [ Result(state=State.OK, notice=f"Read operations: {read_ops:.2f}/s"), Metric("disk_read_ios", read_ops), Result(state=State.OK, notice=f"Write operations: {write_ops:.2f}/s"), Metric("disk_write_ios", write_ops), ] assert result == expected_result
def check_proxmox_ve_disk_usage(params: Mapping[str, Any], section: Section) -> CheckResult: """ >>> for result in check_proxmox_ve_disk_usage( ... {"levels": (80., 90.)}, ... parse_proxmox_ve_disk_usage([['{"disk": 1073741824, "max_disk": 2147483648}']])): ... print(result) Metric('fs_used', 1073741824.0, levels=(1717986918.4, 1932735283.2), boundaries=(0.0, 2147483648.0)) Metric('fs_size', 2147483648.0, boundaries=(0.0, None)) Metric('fs_used_percent', 50.0, levels=(80.0, 90.0), boundaries=(0.0, 100.0)) Result(state=<State.OK: 0>, summary='50.00% used (1.07 GB of 2.15 GB)') """ used_bytes, total_bytes = section.get("disk", 0), section.get("max_disk", 0) warn, crit = params.get("levels", (0.0, 0.0)) warn_bytes, crit_bytes = (warn / 100 * total_bytes, crit / 100 * total_bytes) if total_bytes == 0: yield Result(state=State.WARN, summary="Size of filesystem is 0 MB") return yield Metric( "fs_used", used_bytes, levels=(warn_bytes, crit_bytes), boundaries=(0, total_bytes), ) yield Metric( "fs_size", total_bytes, boundaries=(0, None), ) yield Metric( "fs_used_percent", 100.0 * used_bytes / total_bytes, levels=(warn, crit), boundaries=(0.0, 100.0), ) yield Result( state=(State.CRIT if used_bytes >= crit_bytes else State.WARN if used_bytes >= warn_bytes else State.OK), summary="%s used (%s of %s)" % ( render.percent(100.0 * used_bytes / total_bytes), render.disksize(used_bytes), render.disksize(total_bytes), ), )
def test_check_netscaler_vservers_clustered_best(clustered_vservers): assert list( _check_netscaler_vservers( Parameters({ "health_levels": (100.0, 0.1), "cluster_status": "best", }), clustered_vservers, ) ) == [ Result(state=state.OK, summary='Status: up (node1)', details='Status: up (node1)'), Result(state=state.OK, summary='Status: busy (node2)', details='Status: busy (node2)'), Result(state=state.WARN, summary='Health: 75.2% (warn/crit below 100%/0.10%)', details='Health: 75.2% (warn/crit below 100%/0.10%)'), Metric('health_perc', 75.2, levels=(None, None), boundaries=(0.0, 100.0)), Result( state=state.OK, summary='Type: loadbalancing, Protocol: ssl, Socket: 0.0.0.0:0', details='Type: loadbalancing, Protocol: ssl, Socket: 0.0.0.0:0'), Result(state=state.OK, summary='Request rate: 1/s', details='Request rate: 1/s'), Metric('request_rate', 1.0, levels=(None, None), boundaries=(None, None)), Result(state=state.OK, summary='In: 16.0 Bit/s', details='In: 16.0 Bit/s'), Metric('if_in_octets', 2.0, levels=(None, None), boundaries=(None, None)), Result(state=state.OK, summary='Out: 40.0 Bit/s', details='Out: 40.0 Bit/s'), Metric('if_out_octets', 5.0, levels=(None, None), boundaries=(None, None)), ]
def test_basic_cpu_loads(): section = parse_cpu(STRING_TABLE) # type: ignore[arg-type] assert section result = list( check_cpu_load( params={"levels": (5.0, 10.0)}, section=section, )) assert result == [ Result(state=State.OK, summary="15 min load: 0.87"), Metric("load15", 0.87, levels=(40.0, 80.0)), Result(state=State.OK, summary="15 min load per core: 0.11 (8 cores)"), Metric("load1", 0.88, boundaries=(0.0, 8.0)), Metric("load5", 0.83, boundaries=(0.0, 8.0)), ]
def test_check_job3_item(section: jn.Section) -> None: assert list(jn.check_jenkins_jobs("project/Job3", {}, section)) == [ jn.Result(state=jn.State.OK, summary="Display name: Job 3"), jn.Result(state=jn.State.OK, summary="State: Success"), jn.Result(state=jn.State.OK, summary="Job score: 100.00%"), Metric("jenkins_job_score", 100.0), jn.Result(state=jn.State.OK, summary="Time since last build: 7 days 1 hour"), Metric("jenkins_last_build", 609957.0), jn.Result(state=jn.State.OK, summary="Time since last successful build: 7 days 1 hour"), Metric("jenkins_time_since", 609956.5680000782), jn.Result(state=jn.State.OK, summary="Build id: 26"), jn.Result(state=jn.State.OK, summary="Build duration: 3 minutes 14 seconds"), Metric("jenkins_build_duration", 193.715), jn.Result(state=jn.State.CRIT, summary="Build result: Failure"), ]
def test_check_sap_hana_backup_CRIT(): params = {"backup_age": (1 * 60 * 60, 2 * 60 * 60)} yielded_results = list( sap_hana_backup.check_sap_hana_backup(ITEM, params, SECTION)) assert yielded_results == [ Result(state=state.OK, summary='Status: successful', details='Status: successful'), Result(state=state.OK, summary='Last: 2019-01-01 00:00:00', details='Last: 2019-01-01 00:00:00'), Result( state=state.CRIT, summary= 'Age: 22 hours 54 minutes (warn/crit at 1 hour 0 minutes/2 hours 0 minutes)', details= 'Age: 22 hours 54 minutes (warn/crit at 1 hour 0 minutes/2 hours 0 minutes)' ), Metric('backup_age', 82457.0, levels=(3600.0, 7200.0)), Result(state=state.OK, summary='Message: <ok>', details='Message: <ok>'), ]
def check_bluecat_dhcp_one_lease(): assert list( bluecat_dhcp.check_bluecat_dhcp( { "oper_states": { "warning": [], "critical": [], }, }, { "oper_state": 1, "leases": 1, }, )) == [ Result( state=state.OK, summary="DHCP is running normally", ), Result( state=state.OK, summary="1 lease per second", ), Metric( "leases", 1, ), ]
def check_bluecat_dhcp_crit(): assert list( bluecat_dhcp.check_bluecat_dhcp( { "oper_states": { "warning": [], "critical": [5], }, }, { "oper_state": 5, "leases": 10, }, )) == [ Result( state=state.CRIT, summary="DHCP is fault", ), Result( state=state.OK, summary="1 lease per second", ), Metric( "leases", 1, ), ]
def test_fix_state(): local_result = local.LocalResult( cached=None, item="NotGood", state=State.CRIT, apply_levels=False, text="A critical check", perfdata=[ local.Perfdata( name="V", value=120, levels_upper=(50, 100), levels_lower=None, boundaries=(0, 1000), ) ], ) assert list( local.check_local( "NotGood", {}, local.LocalSection(errors=[], data={"NotGood": local_result}))) == [ Result(state=State.CRIT, summary="A critical check"), Result(state=State.OK, summary='V: 120.00'), Metric("V", 120, boundaries=(0, 1000)), ]
def test_cluster_check_pulse_secure_users(): assert list( pulse_secure_users.cluster_check_pulse_secure_users( {}, { 'node1': { 'n_users': 20 }, 'node2': { 'n_users': 30 } }, )) == [ Result( state=state.OK, notice='[node1]: Pulse Secure users: 20', ), Result( state=state.OK, notice='[node2]: Pulse Secure users: 30', ), Result( state=state.OK, summary='Pulse Secure users across cluster: 50', details='Pulse Secure users across cluster: 50', ), Metric( 'current_users', 50.0, levels=(None, None), boundaries=(None, None), ), ]
def test_check_sansymphony_pool_status_running_cache_mode_readwrite() -> None: section = { "Disk_pool_1": SansymphonyPool( name="Disk_pool_1", percent_allocated=57.0, status="Running", cache_mode="ReadWrite", pool_type="Dynamic", ), } assert list( check_sansymphony_pool( item="Disk_pool_1", params={"allocated_pools_percentage_upper": (80.0, 90.0)}, section=section, ) ) == [ Result( state=State.OK, summary= "Dynamic pool Disk_pool_1 is Running, its cache is in ReadWrite mode", ), Result(state=State.OK, summary="Pool allocation: 57.00%"), Metric("pool_allocation", 57.0, levels=(80.0, 90.0), boundaries=(0.0, 100.0)), ]
def test_cluster_check_sap_hana_backup_CRIT(): params = {"backup_age": (1 * 60 * 60, 2 * 60 * 60)} section = {"node0": SECTION, "node1": SECTION} yielded_results = list( sap_hana_backup.cluster_check_sap_hana_backup(ITEM, params, section)) assert yielded_results == [ Result(state=state.OK, summary='Nodes: node0, node1', details='Nodes: node0, node1'), Result(state=state.OK, summary='Status: successful', details='Status: successful'), Result(state=state.OK, summary='Last: 2019-01-01 00:00:00', details='Last: 2019-01-01 00:00:00'), Result( state=state.CRIT, summary= 'Age: 22 hours 54 minutes (warn/crit at 1 hour 0 minutes/2 hours 0 minutes)', details= 'Age: 22 hours 54 minutes (warn/crit at 1 hour 0 minutes/2 hours 0 minutes)' ), Metric('backup_age', 82457.0, levels=(3600.0, 7200.0), boundaries=(None, None)), Result(state=state.OK, summary='Message: <ok>', details='Message: <ok>'), ]
def test_check2() -> None: assert list( check_mssql_jobs( "Wartung Stündlich", { "ignore_db_status": False, "status_disabled_jobs": 0, "status_missing_jobs": 2, "run_duration": (1800, 2400), }, parse_mssql_jobs(INFO2), ) ) == [ Result(state=State.OK, summary="Last duration: 9 seconds"), Metric("database_job_duration", 9.0, levels=(1800.0, 2400.0)), Result(state=State.CRIT, summary="MSSQL status: Fail"), Result(state=State.OK, summary="Last run: 2020-09-28 15:15:00"), Result(state=State.OK, summary="Next run: 2020-09-28 16:15:00"), Result( state=State.OK, notice= ("Outcome message: The job failed. JobManager tried to run a non-existent" " step (3) for job Wartung Stündlich."), ), ]
def check_kube_pod_resources( params: Params, section_kube_pod_resources: Optional[PodResources], section_kube_allocatable_pods: Optional[AllocatablePods], ) -> CheckResult: assert section_kube_pod_resources is not None, "Missing Api data" yield from check_kube_pods(params, section_kube_pod_resources) if section_kube_allocatable_pods is None: return yield Result( state=State.OK, summary=_summary("allocatable", section_kube_allocatable_pods.allocatable), ) yield Result( state=State.OK, notice=_summary("capacity", section_kube_allocatable_pods.capacity), ) if section_kube_allocatable_pods.kubernetes_object == "cluster": param = params["free_cluster"] elif section_kube_allocatable_pods.kubernetes_object == "node": param = params["free_node"] else: raise AssertionError("Unknown Kubernetes object with capacity.") yield from check_free_pods( param, section_kube_pod_resources, section_kube_allocatable_pods.allocatable, ) yield Metric(name="kube_pod_allocatable", value=section_kube_allocatable_pods.allocatable)
def test_uptime_check_zero(): with on_time("2018-04-15 16:50", "CET"): assert list(uptime_utils.check({}, uptime_utils.Section(0, None))) == [ Result(state=State.OK, summary="Up since Apr 15 2018 18:50:00"), Result(state=State.OK, summary="Uptime: 0 seconds"), Metric("uptime", 0.0), ]
def check_bluecat_dhcp_crit(): assert list( bluecat_dhcp.check_bluecat_dhcp( type_defs.Parameters( { "oper_states": { "warning": [], "critical": [5], }, }, ), { 'oper_state': 5, 'leases': 10, }, )) == [ Result( state=state.CRIT, summary="DHCP is fault", ), Result( state=state.OK, summary="1 lease per second", ), Metric( 'leases', 1, ), ]
def test_fix_state(): local_result = local.LocalResult( cached=None, item="NotGood", state=2, text="A critical check", perfdata=[ local.Perfdata( name="V", value=120, levels=(50, 100, None, None), tuple=("V", 120, 50, 100, 0, 1000), ) ], ) assert list(local.check_local("NotGood", {}, {"NotGood": local_result})) == [ Result(state=state.CRIT, summary="A critical check"), Metric("V", 120, levels=(50, 100), boundaries=(0, 1000)), ]
def test_check3() -> None: assert list( check_mssql_jobs( "aller 2h", { "ignore_db_status": True, "status_disabled_jobs": 0, "status_missing_jobs": 2, "run_duration": (1800, 2400), }, parse_mssql_jobs(INFO2), ) ) == [ Result(state=State.OK, summary="Last duration: 12 minutes 45 seconds"), Metric("database_job_duration", 765.0, levels=(1800.0, 2400.0)), Result(state=State.OK, summary="MSSQL status: Succeed"), Result(state=State.OK, summary="Last run: 2020-09-28 15:05:01"), Result(state=State.OK, summary="Next run: 2020-09-28 17:05:00"), Result( state=State.OK, notice= ("Outcome message: The job succeeded. The Job was invoked by Schedule 48 (Mo-" "Sa 07:00 aller 2h). The last step to run was step 2 (Magicinfo_Device_IP)." ), ), ]
def check_bluecat_dhcp_ok(): assert list( bluecat_dhcp.check_bluecat_dhcp( { "oper_states": { "warning": [], "critical": [], }, }, { 'oper_state': 1, 'leases': 11, }, )) == [ Result( state=state.OK, summary="DHCP is running normally", ), Result( state=state.OK, summary="11 leases per second", ), Metric( 'leases', 11, ), ]
def test_check_kube_node_count_default_params_cp_zero() -> None: result = list( check( check_default_parameters, NodeCount( worker=ReadyCount(ready=10, not_ready=2), control_plane=ReadyCount(ready=0, not_ready=0), ), )) assert result == [ Result(state=State.OK, summary="Worker nodes 10/12"), Metric("kube_node_count_worker_ready", 10.0, boundaries=(0.0, None)), Metric("kube_node_count_worker_not_ready", 2.0), Metric("kube_node_count_worker_total", 12.0), Result(state=State.OK, summary="No control plane nodes found"), ]