From c8ae2e0a3dbfe6a9ba8be426caa1a76ff0c1f457 Mon Sep 17 00:00:00 2001 From: Jan Wagner Date: Tue, 22 Mar 2022 17:54:22 +0100 Subject: [PATCH] Adding ethMon plugin --- ethMon/LICENSE | 208 +++++++++++++++++++++++++++++++++ ethMon/Makefile | 3 + ethMon/README.rst | 96 ++++++++++++++++ ethMon/control | 6 + ethMon/copyright | 5 + ethMon/ethMon | 288 ++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 606 insertions(+) create mode 100644 ethMon/LICENSE create mode 100644 ethMon/Makefile create mode 100644 ethMon/README.rst create mode 100644 ethMon/control create mode 100644 ethMon/copyright create mode 100644 ethMon/ethMon diff --git a/ethMon/LICENSE b/ethMon/LICENSE new file mode 100644 index 0000000..e47c4af --- /dev/null +++ b/ethMon/LICENSE @@ -0,0 +1,208 @@ +Apache License + +Version 2.0, January 2004 + +http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, +AND DISTRIBUTION + + 1. Definitions. + + + +"License" shall mean the terms and conditions for use, reproduction, and distribution +as defined by Sections 1 through 9 of this document. + + + +"Licensor" shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + + + +"Legal Entity" shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, "control" means (i) the power, direct +or indirect, to cause the direction or management of such entity, whether +by contract or otherwise, or (ii) ownership of fifty percent (50%) or more +of the outstanding shares, or (iii) beneficial ownership of such entity. + + + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions +granted by this License. + + + +"Source" form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + + + +"Object" form shall mean any form resulting from mechanical transformation +or translation of a Source form, including but not limited to compiled object +code, generated documentation, and conversions to other media types. + + + +"Work" shall mean the work of authorship, whether in Source or Object form, +made available under the License, as indicated by a copyright notice that +is included in or attached to the work (an example is provided in the Appendix +below). + + + +"Derivative Works" shall mean any work, whether in Source or Object form, +that is based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative +Works shall not include works that remain separable from, or merely link (or +bind by name) to the interfaces of, the Work and Derivative Works thereof. + + + +"Contribution" shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative +Works thereof, that is intentionally submitted to Licensor for inclusion in +the Work by the copyright owner or by an individual or Legal Entity authorized +to submit on behalf of the copyright owner. For the purposes of this definition, +"submitted" means any form of electronic, verbal, or written communication +sent to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, and +issue tracking systems that are managed by, or on behalf of, the Licensor +for the purpose of discussing and improving the Work, but excluding communication +that is conspicuously marked or otherwise designated in writing by the copyright +owner as "Not a Contribution." + + + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf +of whom a Contribution has been received by Licensor and subsequently incorporated +within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this +License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable copyright license to reproduce, prepare +Derivative Works of, publicly display, publicly perform, sublicense, and distribute +the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, +each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable (except as stated in this section) patent +license to make, have made, use, offer to sell, sell, import, and otherwise +transfer the Work, where such license applies only to those patent claims +licensable by such Contributor that are necessarily infringed by their Contribution(s) +alone or by combination of their Contribution(s) with the Work to which such +Contribution(s) was submitted. If You institute patent litigation against +any entity (including a cross-claim or counterclaim in a lawsuit) alleging +that the Work or a Contribution incorporated within the Work constitutes direct +or contributory patent infringement, then any patent licenses granted to You +under this License for that Work shall terminate as of the date such litigation +is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or +Derivative Works thereof in any medium, with or without modifications, and +in Source or Object form, provided that You meet the following conditions: + +(a) You must give any other recipients of the Work or Derivative Works a copy +of this License; and + +(b) You must cause any modified files to carry prominent notices stating that +You changed the files; and + +(c) You must retain, in the Source form of any Derivative Works that You distribute, +all copyright, patent, trademark, and attribution notices from the Source +form of the Work, excluding those notices that do not pertain to any part +of the Derivative Works; and + +(d) If the Work includes a "NOTICE" text file as part of its distribution, +then any Derivative Works that You distribute must include a readable copy +of the attribution notices contained within such NOTICE file, excluding those +notices that do not pertain to any part of the Derivative Works, in at least +one of the following places: within a NOTICE text file distributed as part +of the Derivative Works; within the Source form or documentation, if provided +along with the Derivative Works; or, within a display generated by the Derivative +Works, if and wherever such third-party notices normally appear. The contents +of the NOTICE file are for informational purposes only and do not modify the +License. You may add Your own attribution notices within Derivative Works +that You distribute, alongside or as an addendum to the NOTICE text from the +Work, provided that such additional attribution notices cannot be construed +as modifying the License. + +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, +or distribution of Your modifications, or for any such Derivative Works as +a whole, provided Your use, reproduction, and distribution of the Work otherwise +complies with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any +Contribution intentionally submitted for inclusion in the Work by You to the +Licensor shall be under the terms and conditions of this License, without +any additional terms or conditions. Notwithstanding the above, nothing herein +shall supersede or modify the terms of any separate license agreement you +may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, +trademarks, service marks, or product names of the Licensor, except as required +for reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to +in writing, Licensor provides the Work (and each Contributor provides its +Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, either express or implied, including, without limitation, any warranties +or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR +A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness +of using or redistributing the Work and assume any risks associated with Your +exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether +in tort (including negligence), contract, or otherwise, unless required by +applicable law (such as deliberate and grossly negligent acts) or agreed to +in writing, shall any Contributor be liable to You for damages, including +any direct, indirect, special, incidental, or consequential damages of any +character arising as a result of this License or out of the use or inability +to use the Work (including but not limited to damages for loss of goodwill, +work stoppage, computer failure or malfunction, or any and all other commercial +damages or losses), even if such Contributor has been advised of the possibility +of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work +or Derivative Works thereof, You may choose to offer, and charge a fee for, +acceptance of support, warranty, indemnity, or other liability obligations +and/or rights consistent with this License. However, in accepting such obligations, +You may act only on Your own behalf and on Your sole responsibility, not on +behalf of any other Contributor, and only if You agree to indemnify, defend, +and hold each Contributor harmless for any liability incurred by, or claims +asserted against, such Contributor by reason of your accepting any such warranty +or additional liability. END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets "[]" replaced with your own identifying +information. (Don't include the brackets!) The text should be enclosed in +the appropriate comment syntax for the file format. We also recommend that +a file or class name and description of purpose be included on the same "printed +page" as the copyright notice for easier identification within third-party +archives. + +Copyright 2020 githubDante - + +Licensed under the Apache License, Version 2.0 (the "License"); + +you may not use this file except in compliance with the License. + +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software + +distributed under the License is distributed on an "AS IS" BASIS, + +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + +See the License for the specific language governing permissions and + +limitations under the License. diff --git a/ethMon/Makefile b/ethMon/Makefile new file mode 100644 index 0000000..307e59d --- /dev/null +++ b/ethMon/Makefile @@ -0,0 +1,3 @@ +DOCFILES := README.rst + +include ../common.mk diff --git a/ethMon/README.rst b/ethMon/README.rst new file mode 100644 index 0000000..a8526fb --- /dev/null +++ b/ethMon/README.rst @@ -0,0 +1,96 @@ +*********** +**ethMon** +*********** + +ethMon is an Icinga2/Nagios compatible Python plugin for network traffic monitoring on a specific interface. +Currently the carbon/graphite data is always in *bytes*. + +Graph drawn from a collected data + +.. image:: images/plugin_graph.png + +In order to calculate the speed the plugin keeps the data from previous runs in ~/.ethMonCache.db + +**Installation** +================= +* Download ethMon to the Icinga/Nagios plugin directory (`/usr/lib/nagios/plugins/` on Debian 10) + * `Link `_ +* Ensure that the executable bit of *ethMon* is set + + +**Configuration** +================= + +* In order to use the plugin with Icinga the following configuration is needed: + * in */usr/share/icinga2/include/command-plugins.conf* add the following + + .. code-block:: console + + template CheckCommand "ethMon-common" { + command = [ PluginDir + "/ethMon" ] + arguments = { + "-i" = { + value = "$interface$" + description = "Interface which will be monitored" + } + "-w" = { + value = "$speed_warn$" + description = "Warning threshold" + } + "-c" = { + value = "$speed_crit$" + description = "Critical threshold" + } + "-s" = { + value = "$speed_scale$" + description = "Speed scaling" + } + "--interval" = { + value = "$chk_interval$" + description = "Interval between the checks (in seconds)" + } + } + vars.speed_warn = 60 + vars.speed_crit = 100 + vars.speed_scale = "Mb" + vars.chk_interval = 30 + } + object CheckCommand "ethMon" { + import "ethMon-common" + } + .. + + * then per host (or zone if the interface name match everywhere): + + .. code-block:: console + + apply Service "Traffic-enp3s5" { + check_command = "ethMon" + check_interval = 30 + vars.interface = "enp3s5" + command_endpoint = host.vars.client_endpoint // Check executed on client node + assign where host.vars.client_endpoint == "TheMonitoredHost" // The service is applied only to this node + } + .. + + * **NOTE**: The same value must be used for *check_interval & vars.chk_interval* + +**Support for threshold ranges** + +* `Icinga threshold ranges documentation `_ + + +The plugin has partial support for the ranges described in the Icinga documentation. If used the ranges must be specified for both (warning & critical) parameters. + Implemented are the following specifications: + * min:max - The value must be outside the range in order the alert to be triggered + * @min:max - The value must be inside the range in order the alert to be triggered + * min: - The value must be below *min* or above 10*10^256 in order the alert to be triggered + * @min: - The value must be between *min* and 10*10^256 in order the alert to be triggered + * :max - The value must be below 0 and *max* in order the alert to be triggered + * @:max - The value must be between 0 and *max* in order the alert to be triggered + + +**Motivation** +================ + +The plugin has been created as *check_eth* from Nagios Exchange refused to work in my current setup. diff --git a/ethMon/control b/ethMon/control new file mode 100644 index 0000000..5425ee8 --- /dev/null +++ b/ethMon/control @@ -0,0 +1,6 @@ +Uploaders: Jan Wagner +Recommends: python3-minimal +Version: 1.1.0 +Homepage: https://github.com/githubDante/ethMon +Watch: https://github.com/githubDante/ethMon/tags .*/v?(\d\S+)\.tar\.gz +Description: Plugin for network traffic monitoring on a specific interface diff --git a/ethMon/copyright b/ethMon/copyright new file mode 100644 index 0000000..02226cf --- /dev/null +++ b/ethMon/copyright @@ -0,0 +1,5 @@ +Copyright: (c) github@dante.tk +License: Apache License 2.0 + +On Debian systems, a copy of the Apache License 2.0 can be found in +/usr/share/common-licenses/Apache-2.0 diff --git a/ethMon/ethMon b/ethMon/ethMon new file mode 100644 index 0000000..7fc3af3 --- /dev/null +++ b/ethMon/ethMon @@ -0,0 +1,288 @@ +#!/usr/bin/env python3 + +from argparse import ArgumentParser, Namespace +import re +from typing import Any, List, Dict, Tuple, Optional +import shelve +import sys +from pathlib import Path + +__PREV_DATA__ = '{}/.ethMonCache'.format(Path.home().as_posix()) +__total__ = 'tot_{}' +__old__ = 'old_{}' + +__scale__ = { + 'KB': lambda x: x / 1000, + 'Kb': lambda x: (x*8) / 1000, + 'MB': lambda x: x / 1000**2, + 'Mb': lambda x: (x*8) / 1000**2, + 'GB': lambda x: x / 1000**3, + 'Gb': lambda x: (x*8) / 1000**3 +} + +__to_bytes__ = { + 'KB': lambda x: x * 1000, + 'Kb': lambda x: (x * 1000) / 8, + 'MB': lambda x: x * 1000**2, + 'Mb': lambda x: (x * 1000**2) / 8, + 'GB': lambda x: x * 1000**3, + 'Gb': lambda x: (x * 1000**3) / 8 +} + + +def options_parser() -> Namespace: + _scalers = [i for i in __scale__.keys()] + parser = ArgumentParser('ethMon') + parser.add_argument('-i', '--interface', required=True, type=str, help='Network interface') + parser.add_argument('-w', '--warning', type=str, required=True, help='Warning threshold') + parser.add_argument('-c', '--critical', type=str, required=True, help='Critical threshold') + parser.add_argument('-s', '--scale', choices=_scalers, help='Scaled results {}'.format(_scalers)) + parser.add_argument('--interval', type=int, help='Interval between the checks (in seconds)') + + return parser.parse_args() + + +def threshold_spec(threshold: str) -> bool: + """ + Check for ranges specified in the warning/critical options + """ + try: + x, y = threshold.split(':') + return True + except ValueError: + return False + +def to_int(x: str) -> int: + """ + Try to convert a value to integer. Always returns zero on unsuccessfull conversion + + :param x: Any + """ + try: + return int(x) + except: + return 0 + +def threshold_extract(threshold: str) -> Tuple[int, int, bool]: + """ + Extract the range and the inner/outer parameter + + + :return: upper (int), lower (int), inner (bool) + """ + lower, upper = threshold.split(':') + if lower == '': + lower = 0 + if upper == '': + """ Set the upper limit to a very large number if not specified """ + upper = 10*10**256 + if lower.startswith('@'): + lower = lower.lstrip('@') + inner = True + else: + inner = False + + if to_int(lower) > to_int(upper): + raise ValueError('Invalid value in threshold specification. lower > upper') + return to_int(lower), to_int(upper), inner + + +def get_old_data(iface: str) -> Tuple[int, int, int, int]: + """ + Get the old interface data from the storage (if available) + + :param iface: The name of the interface + :return: RX bytes, TX bytes, RX Total, TX Total values from the previous run + """ + storage = shelve.open(__PREV_DATA__) + rx, tx = storage.get(__old__.format(iface), (0, 0)) + rx_total, tx_total = storage.get(__total__.format(iface), (0, 0)) + storage.close() + return rx, tx, rx_total, tx_total + + +def update_stats(iface: str, rx_bytes: int, tx_bytes: int) -> None: + """ + Store the data from the current run + + :param iface: The name of the interface + :param rx_bytes: RX bytes as read from the net/dev file + :param tx_bytes: TX bytes values as read from the net/dev file + :return: + """ + storage = shelve.open(__PREV_DATA__) + rx_total, tx_total = storage.get(__total__.format(iface), (0, 0)) + storage[__total__.format(iface)] = (rx_total + rx_bytes, tx_total + tx_bytes) + storage[__old__.format(iface)] = (rx_bytes, tx_bytes) + storage.close() + return + + +def get_iface_stats(iface: str) -> Tuple[int, int]: + """ + Extract the interface statistics + + :param iface: + :return: + """ + """ + RX/TX slots + bytes packets errs drop fifo frame compressed multicast + """ + _rx_bytes = 0 + _tx_bytes = 0 + slots = [] + with open('/proc/net/dev', 'r') as stat: + for line in stat: + if iface not in line: + continue + line = line.rstrip() + line = re.sub(r'\s\s+', ' ', line) + line = line.lstrip(' ') + slots = line.split(' ') + if len(slots) > 10: + _rx_bytes = int(slots[1]) + _tx_bytes = int(slots[9]) + return _rx_bytes, _tx_bytes + + +def speed_calc(old_data: tuple, current_data: tuple) -> Tuple[int, int]: + """ + Calculate the changes between the old and new data + + :param data: + :param current_data: + :return: + """ + old_rx, old_tx = old_data[:2] + cur_rx, cur_tx = current_data + + return cur_rx - old_rx, cur_tx - old_tx + + +def speed_scaler(val: int, scaler: str) -> str: + """ + available ['KB', 'Kb', 'MB', 'Mb', 'GB', 'Gb'] + """ + if scaler not in __scale__.keys(): + raise + return str(round(__scale__[scaler](val), 3)) + + +def speed_normalizer(val: int, scaler: str) -> int: + """ + available ['KB', 'Kb', 'MB', 'Mb', 'GB', 'Gb'] + """ + if scaler not in __to_bytes__.keys(): + raise + return int(__to_bytes__[scaler](val)) + + +def final_string(rx_s: int, tx_s: int, warning_s: int, crit_s: int, code: int): + status = 'OK' + if code == 2: + status = 'CRITICAL' + elif code == 1: + status = 'WARNING' + + return '{} bandwidth utilization | rx={}B;{}B;{}B tx={}B;{}B;{}B'.format( + status, rx_s, warning_s, crit_s, tx_s, warning_s, crit_s + ) + + +if __name__ == '__main__': + options = options_parser() + old = get_old_data(options.interface) + exit_c = 0 + if threshold_spec(options.warning) or threshold_spec(options.critical): + use_thresholds = True + try: + warn_lower, warn_upper, warn_inner = threshold_extract(options.warning) + crit_lower, crit_upper, crit_inner = threshold_extract(options.critical) + except ValueError: + print('Invalid range specification.') + sys.exit(100) + else: + use_thresholds = False + + current = get_iface_stats(options.interface) + rx_speed, tx_speed = speed_calc(old, current) + + if options.interval: + interval_scaler = lambda x: int(x / options.interval) + rx_speed = interval_scaler(rx_speed) + tx_speed = interval_scaler(tx_speed) + + update_stats(options.interface, *current) + + if options.scale: + _suffix = ' {}'.format(options.scale) + c_0 = speed_scaler(current[0], options.scale) + _suffix + c_1 = speed_scaler(current[1], options.scale) + _suffix + rx_s = speed_scaler(rx_speed, options.scale) + _suffix + tx_s = speed_scaler(tx_speed, options.scale) + _suffix + + if use_thresholds is False: + warning_s = speed_normalizer(to_int(options.warning), options.scale) + if warning_s < rx_speed or warning_s < tx_speed: + exit_c = 1 + critical_s = speed_normalizer(to_int(options.critical), options.scale) + if critical_s < rx_speed or critical_s < tx_speed: + exit_c = 2 + else: + warn_s_low = speed_normalizer(warn_lower, options.scale) + warn_s_up = speed_normalizer(warn_upper, options.scale) + crit_s_low = speed_normalizer(crit_lower, options.scale) + crit_s_up = speed_normalizer(crit_upper, options.scale) + + if warn_inner is True: + if (warn_s_low <= rx_speed <= warn_s_up) or (warn_s_low <= tx_speed <= warn_s_up): + exit_c = 1 + else: + if (warn_s_low >= rx_speed or warn_s_up <= rx_speed) or (warn_s_low >= tx_speed or warn_s_up <= tx_speed): + exit_c = 1 + if crit_inner is True: + if (crit_s_low <= rx_speed <= crit_s_up) or (crit_s_low <= tx_speed <= crit_s_up): + exit_c = 2 + else: + if (crit_s_low >= rx_speed or crit_s_up <= rx_speed) or (crit_s_low >= tx_speed or crit_s_up <= tx_speed): + exit_c = 2 + warning_s = warn_s_low + critical_s = crit_s_low + + + print('RX {}: {}, TX {}: {}; RX speed: {} TX speed: {}'.format( + options.scale, c_0, options.scale, c_1, rx_s, tx_s + ), end='; ') + print(final_string(rx_speed, tx_speed, warning_s, critical_s, exit_c)) + + else: + print('RX bytes: {}, TX bytes: {}; RX speed: {}, TX speed {}'.format( + current[0], rx_speed, current[1], tx_speed + ), end='; ') + if use_thresholds is False: + warning_s = to_int(options.warning) + if warning_s < rx_speed or warning_s < tx_speed: + exit_c = 1 + critical_s = to_int(options.critical) + if critical_s < rx_speed or critical_s <= tx_speed: + exit_c = 2 + else: + if crit_inner is True: + if (warn_lower <= rx_speed <= warn_upper) or (warn_lower <= tx_speed <= warn_upper): + exit_c = 1 + else: + if (warn_lower >= rx_speed or warn_upper <= rx_speed) or (warn_lower >= tx_speed or warn_upper <= rx_speed): + exit_c = 1 + if crit_inner is True: + if (crit_lower <= rx_speed <= crit_upper) or (crit_lower <= tx_speed <= crit_upper): + exit_c = 2 + else: + if (crit_lower >= rx_speed or crit_upper <= rx_speed) or (crit_lower >= tx_speed or crit_upper <= tx_speed): + exit_c = 2 + warning_s = warn_lower + critical_s = crit_lower + + print(final_string(rx_speed, tx_speed, warning_s, critical_s, exit_c)) + + sys.exit(exit_c)