From: Florian Forster Date: Sun, 5 Dec 2010 10:05:43 +0000 (+0100) Subject: threshold plugin: Move the threshold checking code into a plugin. X-Git-Tag: collectd-5.0.0-beta0~11 X-Git-Url: https://git.verplant.org/?a=commitdiff_plain;h=171a92c968cb41c314736b0d26f5a6ba2ae59666;p=collectd.git threshold plugin: Move the threshold checking code into a plugin. --- diff --git a/README b/README index 2ed8934f..e8b7241b 100644 --- a/README +++ b/README @@ -442,6 +442,10 @@ Features * Miscellaneous plugins: + - threshold + Checks values against configured thresholds and creates notifications if + values are out of bounds. See collectd-threshold(5) for details. + - uuid Sets the hostname to an unique identifier. This is meant for setups where each client may migrate to another physical host, possibly going diff --git a/configure.in b/configure.in index 3b46188a..8ec84155 100644 --- a/configure.in +++ b/configure.in @@ -4637,6 +4637,7 @@ AC_PLUGIN([tcpconns], [$plugin_tcpconns], [TCP connection statistics]) AC_PLUGIN([teamspeak2], [yes], [TeamSpeak2 server statistics]) AC_PLUGIN([ted], [$plugin_ted], [Read The Energy Detective values]) AC_PLUGIN([thermal], [$plugin_thermal], [Linux ACPI thermal zone statistics]) +AC_PLUGIN([threshold], [yes], [Threshold checking plugin]) AC_PLUGIN([tokyotyrant], [$with_libtokyotyrant], [TokyoTyrant database statistics]) AC_PLUGIN([unixsock], [yes], [Unixsock communication plugin]) AC_PLUGIN([uptime], [$plugin_uptime], [Uptime statistics]) @@ -4962,6 +4963,7 @@ Configuration: teamspeak2 . . . . . $enable_teamspeak2 ted . . . . . . . . . $enable_ted thermal . . . . . . . $enable_thermal + threshold . . . . . . $enable_threshold tokyotyrant . . . . . $enable_tokyotyrant unixsock . . . . . . $enable_unixsock uptime . . . . . . . $enable_uptime diff --git a/src/Makefile.am b/src/Makefile.am index 1a7ba5b1..57281440 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -40,7 +40,6 @@ collectd_SOURCES = collectd.c collectd.h \ utils_match.c utils_match.h \ utils_subst.c utils_subst.h \ utils_tail.c utils_tail.h \ - utils_threshold.c utils_threshold.h \ utils_time.c utils_time.h \ types_list.c types_list.h @@ -1131,6 +1130,14 @@ collectd_LDADD += "-dlopen" thermal.la collectd_DEPENDENCIES += thermal.la endif +if BUILD_PLUGIN_THRESHOLD +pkglib_LTLIBRARIES += threshold.la +threshold_la_SOURCES = threshold.c +threshold_la_LDFLAGS = -module -avoid-version +collectd_LDADD += "-dlopen" threshold.la +collectd_DEPENDENCIES += threshold.la +endif + if BUILD_PLUGIN_TOKYOTYRANT pkglib_LTLIBRARIES += tokyotyrant.la tokyotyrant_la_SOURCES = tokyotyrant.c @@ -1149,7 +1156,6 @@ pkglib_LTLIBRARIES += unixsock.la unixsock_la_SOURCES = unixsock.c \ utils_cmd_flush.h utils_cmd_flush.c \ utils_cmd_getval.h utils_cmd_getval.c \ - utils_cmd_getthreshold.h utils_cmd_getthreshold.c \ utils_cmd_listval.h utils_cmd_listval.c \ utils_cmd_putval.h utils_cmd_putval.c \ utils_cmd_putnotif.h utils_cmd_putnotif.c @@ -1286,6 +1292,7 @@ dist_man_MANS = collectd.1 \ collectd-perl.5 \ collectd-python.5 \ collectd-snmp.5 \ + collectd-threshold.5 \ collectd-unixsock.5 \ types.db.5 @@ -1304,6 +1311,7 @@ EXTRA_DIST += collectd.conf.pod \ collectd-python.pod \ collectd.pod \ collectd-snmp.pod \ + collectd-threshold.pod \ collectd-unixsock.pod \ postgresql_default.conf \ types.db.pod diff --git a/src/collectd-threshold.pod b/src/collectd-threshold.pod new file mode 100644 index 00000000..5d1a645c --- /dev/null +++ b/src/collectd-threshold.pod @@ -0,0 +1,194 @@ +=head1 NAME + +collectd-threshold - Documentation of collectd's I + +=head1 SYNOPSIS + + LoadPlugin "threshold" + + + WarningMin 0.00 + WarningMax 1000.00 + FailureMin 0.00 + FailureMax 1200.00 + Invert false + Instance "bar" + + + +=head1 DESCRIPTION + +Starting with version C<4.3.0> I has support for B. By +that we mean that the values are not only stored or sent somewhere, but that +they are judged and, if a problem is recognized, acted upon. The only action +the I takes itself is to generate and dispatch a +I. Other plugins can register to receive notifications and +perform appropriate further actions. + +Since systems and what you expect them to do differ a lot, you can configure +I for your values freely. This gives you a lot of flexibility but +also a lot of responsibility. + +Every time a value is out of range, a notification is dispatched. This means +that the idle percentage of your CPU needs to be less then the configured +threshold only once for a notification to be generated. There's no such thing +as a moving average or similar - at least not now. + +Also, all values that match a threshold are considered to be relevant or +"interesting". As a consequence collectd will issue a notification if they are +not received for B iterations. The B configuration option is +explained in section L. If, for example, +B is set to "2" (the default) and some hosts sends it's CPU statistics +to the server every 60 seconds, a notification will be dispatched after about +120 seconds. It may take a little longer because the timeout is checked only +once each B on the server. + +When a value comes within range again or is received after it was missing, an +"OKAY-notification" is dispatched. + +=head1 CONFIGURATION + +Here is a configuration example to get you started. Read below for more +information. + + LoadPlugin "threshold" + + + WarningMin 0.00 + WarningMax 1000.00 + FailureMin 0.00 + FailureMax 1200.00 + Invert false + Instance "bar" + + + + Instance "eth0" + + FailureMax 10000000 + DataSource "rx" + + + + + + Instance "idle" + FailureMin 10 + + + + + Instance "cached" + WarningMin 100000000 + + + + + DataSource "midterm" + FailureMax 4 + Hits 3 + Hysteresis 3 + + + + +There are basically two types of configuration statements: The C, +C, and C blocks select the value for which a threshold should be +configured. The C and C blocks may be specified further using the +C option. You can combine the block by nesting the blocks, though +they must be nested in the above order, i.e. C may contain either +C and C blocks, C may only contain C blocks and +C may not contain other blocks. If multiple blocks apply to the same +value the most specific block is used. + +The other statements specify the threshold to configure. They B be +included in a C block. Currently the following statements are recognized: + +=over 4 + +=item B I + +=item B I + +Sets the upper bound of acceptable values. If unset defaults to positive +infinity. If a value is greater than B a B notification +will be created. If the value is greater than B but less than (or +equal to) B a B notification will be created. + +=item B I + +=item B I + +Sets the lower bound of acceptable values. If unset defaults to negative +infinity. If a value is less than B a B notification will +be created. If the value is less than B but greater than (or equal +to) B a B notification will be created. + +=item B I + +Some data sets have more than one "data source". Interesting examples are the +C data set, which has received (C) and sent (C) bytes and +the C data set, which holds C and C operations. The +system load data set, C, even has three data sources: C, +C, and C. + +Normally, all data sources are checked against a configured threshold. If this +is undesirable, or if you want to specify different limits for each data +source, you can use the B option to have a threshold apply only to +one data source. + +=item B B|B + +If set to B the range of acceptable values is inverted, i.e. values +between B and B (B and B) are +not okay. Defaults to B. + +=item B B|B + +Sets how often notifications are generated. If set to B one notification +will be generated for each value that is out of the acceptable range. If set to +B (the default) then a notification is only generated if a value is out +of range but the previous value was okay. + +This applies to missing values, too: If set to B a notification about a +missing value is generated once every B seconds. If set to B +only one such notification is generated until the value appears again. + +=item B B|B + +If set to B, the minimum and maximum values given are interpreted as +percentage value, relative to the other data sources. This is helpful for +example for the "df" type, where you may want to issue a warning when less than +5E% of the total space is available. Defaults to B. + +=item B I + +Sets the number of occurrences which the threshold must be raised before to +dispatch any notification or, in other words, the number of Bs +that the threshold must be match before dispatch any notification. + +=item B I + +Sets the hysteresis value for threshold. The hysteresis is a method to prevent +flapping between states, until a new received value for a previously matched +threshold down below the threshold condition (B, B or +everything else) minus the hysteresis value, the failure (respectively warning) +state will be keep. + +=item B B|B + +If set to B (the default), the threshold must be treated as interesting +and, when a number of B values will lost, then a missing notification +will be dispatched. On the other hand, if set to B, the missing +notification will never dispatched for this threshold. + +=back + +=head1 SEE ALSO + +L, +L + +=head1 AUTHOR + +Florian Forster EoctoEatEcollectd.orgE diff --git a/src/collectd.conf.in b/src/collectd.conf.in index 12259098..32a7582c 100644 --- a/src/collectd.conf.in +++ b/src/collectd.conf.in @@ -1000,3 +1000,52 @@ # # Target "write" # + +############################################################################## +# Threshold configuration # +#----------------------------------------------------------------------------# +# The following outlines how to configure collectd's threshold checking # +# plugin. The plugin and possible configuration options are documented in # +# the collectd-threshold(5) manual page. # +############################################################################## + +#@BUILD_PLUGIN_THRESHOLD_TRUE@LoadPlugin "threshold" +# +# +# WarningMin 0.00 +# WarningMax 1000.00 +# FailureMin 0.00 +# FailureMax 1200.00 +# Invert false +# Instance "bar" +# +# +# +# Instance "eth0" +# +# FailureMax 10000000 +# DataSource "rx" +# +# +# +# +# +# Instance "idle" +# FailureMin 10 +# +# +# +# +# Instance "cached" +# WarningMin 100000000 +# +# +# +# +# DataSource "midterm" +# FailureMax 4 +# Hits 3 +# Hysteresis 3 +# +# +# diff --git a/src/collectd.conf.pod b/src/collectd.conf.pod index c1c9a253..acdfa927 100644 --- a/src/collectd.conf.pod +++ b/src/collectd.conf.pod @@ -141,7 +141,7 @@ missing when no update has been received for twice the update interval. Since this setting uses iterations, the maximum allowed time without update depends on the I information contained in each value list. This is used in the I configuration to dispatch notifications about missing values, -see L<"THRESHOLD CONFIGURATION"> below. +see L for details. =item B I @@ -4530,7 +4530,7 @@ port in numeric form. =item B I|I -By default, the C plugin tries to read the statistics from the Linux +By default, the I tries to read the statistics from the Linux C interface. If that is not available, the plugin falls back to the C interface. By setting this option to I, you can force the plugin to use the latter. This option defaults to I. @@ -4550,9 +4550,18 @@ selection is configured at all, B devices are selected. =back +=head2 Plugin C + +The I checks values collected or received by I +against a configurable I and issues I if values are +out of bounds. + +Documentation for this plugin is available in the L +manual page. + =head2 Plugin C -The C connects to a TokyoTyrant server and collects a +The I connects to a TokyoTyrant server and collects a couple metrics: number of records, and database size on disk. =over 4 @@ -4799,170 +4808,6 @@ number. =back -=head1 THRESHOLD CONFIGURATION - -Starting with version C<4.3.0> collectd has support for B. By that -we mean that the values are not only stored or sent somewhere, but that they -are judged and, if a problem is recognized, acted upon. The only action -collectd takes itself is to generate and dispatch a "notification". Plugins can -register to receive notifications and perform appropriate further actions. - -Since systems and what you expect them to do differ a lot, you can configure -B for your values freely. This gives you a lot of flexibility but -also a lot of responsibility. - -Every time a value is out of range a notification is dispatched. This means -that the idle percentage of your CPU needs to be less then the configured -threshold only once for a notification to be generated. There's no such thing -as a moving average or similar - at least not now. - -Also, all values that match a threshold are considered to be relevant or -"interesting". As a consequence collectd will issue a notification if they are -not received for B iterations. The B configuration option is -explained in section L<"GLOBAL OPTIONS">. If, for example, B is set to -"2" (the default) and some hosts sends it's CPU statistics to the server every -60 seconds, a notification will be dispatched after about 120 seconds. It may -take a little longer because the timeout is checked only once each B -on the server. - -When a value comes within range again or is received after it was missing, an -"OKAY-notification" is dispatched. - -Here is a configuration example to get you started. Read below for more -information. - - - - WarningMin 0.00 - WarningMax 1000.00 - FailureMin 0.00 - FailureMax 1200.00 - Invert false - Instance "bar" - - - - Instance "eth0" - - FailureMax 10000000 - DataSource "rx" - - - - - - Instance "idle" - FailureMin 10 - - - - - Instance "cached" - WarningMin 100000000 - - - - - DataSource "midterm" - FailureMax 4 - Hits 3 - Hysteresis 3 - - - - -There are basically two types of configuration statements: The C, -C, and C blocks select the value for which a threshold should be -configured. The C and C blocks may be specified further using the -C option. You can combine the block by nesting the blocks, though -they must be nested in the above order, i.Ee. C may contain either -C and C blocks, C may only contain C blocks and -C may not contain other blocks. If multiple blocks apply to the same -value the most specific block is used. - -The other statements specify the threshold to configure. They B be -included in a C block. Currently the following statements are recognized: - -=over 4 - -=item B I - -=item B I - -Sets the upper bound of acceptable values. If unset defaults to positive -infinity. If a value is greater than B a B notification -will be created. If the value is greater than B but less than (or -equal to) B a B notification will be created. - -=item B I - -=item B I - -Sets the lower bound of acceptable values. If unset defaults to negative -infinity. If a value is less than B a B notification will -be created. If the value is less than B but greater than (or equal -to) B a B notification will be created. - -=item B I - -Some data sets have more than one "data source". Interesting examples are the -C data set, which has received (C) and sent (C) bytes and -the C data set, which holds C and C operations. The -system load data set, C, even has three data sources: C, -C, and C. - -Normally, all data sources are checked against a configured threshold. If this -is undesirable, or if you want to specify different limits for each data -source, you can use the B option to have a threshold apply only to -one data source. - -=item B B|B - -If set to B the range of acceptable values is inverted, i.Ee. -values between B and B (B and -B) are not okay. Defaults to B. - -=item B B|B - -Sets how often notifications are generated. If set to B one notification -will be generated for each value that is out of the acceptable range. If set to -B (the default) then a notification is only generated if a value is out -of range but the previous value was okay. - -This applies to missing values, too: If set to B a notification about a -missing value is generated once every B seconds. If set to B -only one such notification is generated until the value appears again. - -=item B B|B - -If set to B, the minimum and maximum values given are interpreted as -percentage value, relative to the other data sources. This is helpful for -example for the "df" type, where you may want to issue a warning when less than -5E% of the total space is available. Defaults to B. - -=item B I - -Sets the number of occurrences which the threshold must be arised before to -dispatch any notification or, in other words, the number of Bs -than the threshold must be match before dispatch any notification. - -=item B I - -Sets the hysteresis value for threshold. The hysteresis is a method to -prevent flapping between states, until a new received value for -a previously matched threshold down below the threshold condition -(B, B or everthing else) minus the hysteresis value, -the failure (respectively warning) state will be keep. - -=item B B|B - -If set to B (the default), the threshold must be treated as -interesting and, when a number of B values will lost, then -a missing notification will be dispatched. On the other hand, if set to -B, the missing notification will never dispatched for this threshold. - -=back - =head1 FILTER CONFIGURATION Starting with collectd 4.6 there is a powerful filtering infrastructure diff --git a/src/configfile.c b/src/configfile.c index e162dd99..11200f61 100644 --- a/src/configfile.c +++ b/src/configfile.c @@ -29,7 +29,6 @@ #include "plugin.h" #include "configfile.h" #include "types_list.h" -#include "utils_threshold.h" #include "filter_chain.h" #if HAVE_WORDEXP_H @@ -372,8 +371,6 @@ static int dispatch_block (oconfig_item_t *ci) return (dispatch_loadplugin (ci)); else if (strcasecmp (ci->key, "Plugin") == 0) return (dispatch_block_plugin (ci)); - else if (strcasecmp (ci->key, "Threshold") == 0) - return (ut_config (ci)); else if (strcasecmp (ci->key, "Chain") == 0) return (fc_configure (ci)); diff --git a/src/plugin.c b/src/plugin.c index e32c8f9c..a298d350 100644 --- a/src/plugin.c +++ b/src/plugin.c @@ -36,7 +36,6 @@ #include "utils_llist.h" #include "utils_heap.h" #include "utils_cache.h" -#include "utils_threshold.h" #include "filter_chain.h" /* @@ -1525,9 +1524,6 @@ int plugin_dispatch_values (value_list_t *vl) /* Update the value cache */ uc_update (ds, vl); - /* Initiate threshold checking */ - ut_check_threshold (ds, vl); - if (post_cache_chain != NULL) { status = fc_process_chain (ds, vl, post_cache_chain); diff --git a/src/threshold.c b/src/threshold.c new file mode 100644 index 00000000..89397502 --- /dev/null +++ b/src/threshold.c @@ -0,0 +1,968 @@ +/** + * collectd - src/threshold.c + * Copyright (C) 2007-2010 Florian Forster + * Copyright (C) 2008-2009 Sebastian Harl + * Copyright (C) 2009 Andrés J. Díaz + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; only version 2 of the License is applicable. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: + * Florian octo Forster + * Sebastian Harl + * Andrés J. Díaz + **/ + +#include "collectd.h" +#include "common.h" +#include "plugin.h" +#include "utils_avltree.h" +#include "utils_cache.h" + +#include +#include + +/* + * Private data structures + * {{{ */ +#define UT_FLAG_INVERT 0x01 +#define UT_FLAG_PERSIST 0x02 +#define UT_FLAG_PERCENTAGE 0x04 +#define UT_FLAG_INTERESTING 0x08 +typedef struct threshold_s +{ + char host[DATA_MAX_NAME_LEN]; + char plugin[DATA_MAX_NAME_LEN]; + char plugin_instance[DATA_MAX_NAME_LEN]; + char type[DATA_MAX_NAME_LEN]; + char type_instance[DATA_MAX_NAME_LEN]; + char data_source[DATA_MAX_NAME_LEN]; + gauge_t warning_min; + gauge_t warning_max; + gauge_t failure_min; + gauge_t failure_max; + gauge_t hysteresis; + unsigned int flags; + int hits; + struct threshold_s *next; +} threshold_t; +/* }}} */ + +/* + * Private (static) variables + * {{{ */ +static c_avl_tree_t *threshold_tree = NULL; +static pthread_mutex_t threshold_lock = PTHREAD_MUTEX_INITIALIZER; +/* }}} */ + +/* + * Threshold management + * ==================== + * The following functions add, delete, search, etc. configured thresholds to + * the underlying AVL trees. + */ +/* + * threshold_t *threshold_get + * + * Retrieve one specific threshold configuration. For looking up a threshold + * matching a value_list_t, see "threshold_search" below. Returns NULL if the + * specified threshold doesn't exist. + */ +static threshold_t *threshold_get (const char *hostname, + const char *plugin, const char *plugin_instance, + const char *type, const char *type_instance) +{ /* {{{ */ + char name[6 * DATA_MAX_NAME_LEN]; + threshold_t *th = NULL; + + format_name (name, sizeof (name), + (hostname == NULL) ? "" : hostname, + (plugin == NULL) ? "" : plugin, plugin_instance, + (type == NULL) ? "" : type, type_instance); + name[sizeof (name) - 1] = '\0'; + + if (c_avl_get (threshold_tree, name, (void *) &th) == 0) + return (th); + else + return (NULL); +} /* }}} threshold_t *threshold_get */ + +/* + * int ut_threshold_add + * + * Adds a threshold configuration to the list of thresholds. The threshold_t + * structure is copied and may be destroyed after this call. Returns zero on + * success, non-zero otherwise. + */ +static int ut_threshold_add (const threshold_t *th) +{ /* {{{ */ + char name[6 * DATA_MAX_NAME_LEN]; + char *name_copy; + threshold_t *th_copy; + threshold_t *th_ptr; + int status = 0; + + if (format_name (name, sizeof (name), th->host, + th->plugin, th->plugin_instance, + th->type, th->type_instance) != 0) + { + ERROR ("ut_threshold_add: format_name failed."); + return (-1); + } + + name_copy = strdup (name); + if (name_copy == NULL) + { + ERROR ("ut_threshold_add: strdup failed."); + return (-1); + } + + th_copy = (threshold_t *) malloc (sizeof (threshold_t)); + if (th_copy == NULL) + { + sfree (name_copy); + ERROR ("ut_threshold_add: malloc failed."); + return (-1); + } + memcpy (th_copy, th, sizeof (threshold_t)); + th_ptr = NULL; + + DEBUG ("ut_threshold_add: Adding entry `%s'", name); + + pthread_mutex_lock (&threshold_lock); + + th_ptr = threshold_get (th->host, th->plugin, th->plugin_instance, + th->type, th->type_instance); + + while ((th_ptr != NULL) && (th_ptr->next != NULL)) + th_ptr = th_ptr->next; + + if (th_ptr == NULL) /* no such threshold yet */ + { + status = c_avl_insert (threshold_tree, name_copy, th_copy); + } + else /* th_ptr points to the last threshold in the list */ + { + th_ptr->next = th_copy; + /* name_copy isn't needed */ + sfree (name_copy); + } + + pthread_mutex_unlock (&threshold_lock); + + if (status != 0) + { + ERROR ("ut_threshold_add: c_avl_insert (%s) failed.", name); + sfree (name_copy); + sfree (th_copy); + } + + return (status); +} /* }}} int ut_threshold_add */ + +/* + * threshold_t *threshold_search + * + * Searches for a threshold configuration using all the possible variations of + * "Host", "Plugin" and "Type" blocks. Returns NULL if no threshold could be + * found. + * XXX: This is likely the least efficient function in collectd. + */ +static threshold_t *threshold_search (const value_list_t *vl) +{ /* {{{ */ + threshold_t *th; + + if ((th = threshold_get (vl->host, vl->plugin, vl->plugin_instance, + vl->type, vl->type_instance)) != NULL) + return (th); + else if ((th = threshold_get (vl->host, vl->plugin, vl->plugin_instance, + vl->type, NULL)) != NULL) + return (th); + else if ((th = threshold_get (vl->host, vl->plugin, NULL, + vl->type, vl->type_instance)) != NULL) + return (th); + else if ((th = threshold_get (vl->host, vl->plugin, NULL, + vl->type, NULL)) != NULL) + return (th); + else if ((th = threshold_get (vl->host, "", NULL, + vl->type, vl->type_instance)) != NULL) + return (th); + else if ((th = threshold_get (vl->host, "", NULL, + vl->type, NULL)) != NULL) + return (th); + else if ((th = threshold_get ("", vl->plugin, vl->plugin_instance, + vl->type, vl->type_instance)) != NULL) + return (th); + else if ((th = threshold_get ("", vl->plugin, vl->plugin_instance, + vl->type, NULL)) != NULL) + return (th); + else if ((th = threshold_get ("", vl->plugin, NULL, + vl->type, vl->type_instance)) != NULL) + return (th); + else if ((th = threshold_get ("", vl->plugin, NULL, + vl->type, NULL)) != NULL) + return (th); + else if ((th = threshold_get ("", "", NULL, + vl->type, vl->type_instance)) != NULL) + return (th); + else if ((th = threshold_get ("", "", NULL, + vl->type, NULL)) != NULL) + return (th); + + return (NULL); +} /* }}} threshold_t *threshold_search */ + +/* + * Configuration + * ============= + * The following approximately two hundred functions are used to handle the + * configuration and fill the threshold list. + * {{{ */ +static int ut_config_type_datasource (threshold_t *th, oconfig_item_t *ci) +{ + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_STRING)) + { + WARNING ("threshold values: The `DataSource' option needs exactly one " + "string argument."); + return (-1); + } + + sstrncpy (th->data_source, ci->values[0].value.string, + sizeof (th->data_source)); + + return (0); +} /* int ut_config_type_datasource */ + +static int ut_config_type_instance (threshold_t *th, oconfig_item_t *ci) +{ + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_STRING)) + { + WARNING ("threshold values: The `Instance' option needs exactly one " + "string argument."); + return (-1); + } + + sstrncpy (th->type_instance, ci->values[0].value.string, + sizeof (th->type_instance)); + + return (0); +} /* int ut_config_type_instance */ + +static int ut_config_type_max (threshold_t *th, oconfig_item_t *ci) +{ + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) + { + WARNING ("threshold values: The `%s' option needs exactly one " + "number argument.", ci->key); + return (-1); + } + + if (strcasecmp (ci->key, "WarningMax") == 0) + th->warning_max = ci->values[0].value.number; + else + th->failure_max = ci->values[0].value.number; + + return (0); +} /* int ut_config_type_max */ + +static int ut_config_type_min (threshold_t *th, oconfig_item_t *ci) +{ + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) + { + WARNING ("threshold values: The `%s' option needs exactly one " + "number argument.", ci->key); + return (-1); + } + + if (strcasecmp (ci->key, "WarningMin") == 0) + th->warning_min = ci->values[0].value.number; + else + th->failure_min = ci->values[0].value.number; + + return (0); +} /* int ut_config_type_min */ + +static int ut_config_type_hits (threshold_t *th, oconfig_item_t *ci) +{ + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) + { + WARNING ("threshold values: The `%s' option needs exactly one " + "number argument.", ci->key); + return (-1); + } + + th->hits = ci->values[0].value.number; + + return (0); +} /* int ut_config_type_hits */ + +static int ut_config_type_hysteresis (threshold_t *th, oconfig_item_t *ci) +{ + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) + { + WARNING ("threshold values: The `%s' option needs exactly one " + "number argument.", ci->key); + return (-1); + } + + th->hysteresis = ci->values[0].value.number; + + return (0); +} /* int ut_config_type_hysteresis */ + +static int ut_config_type (const threshold_t *th_orig, oconfig_item_t *ci) +{ + int i; + threshold_t th; + int status = 0; + + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_STRING)) + { + WARNING ("threshold values: The `Type' block needs exactly one string " + "argument."); + return (-1); + } + + if (ci->children_num < 1) + { + WARNING ("threshold values: The `Type' block needs at least one option."); + return (-1); + } + + memcpy (&th, th_orig, sizeof (th)); + sstrncpy (th.type, ci->values[0].value.string, sizeof (th.type)); + + th.warning_min = NAN; + th.warning_max = NAN; + th.failure_min = NAN; + th.failure_max = NAN; + th.hits = 0; + th.hysteresis = 0; + th.flags = UT_FLAG_INTERESTING; /* interesting by default */ + + for (i = 0; i < ci->children_num; i++) + { + oconfig_item_t *option = ci->children + i; + status = 0; + + if (strcasecmp ("Instance", option->key) == 0) + status = ut_config_type_instance (&th, option); + else if (strcasecmp ("DataSource", option->key) == 0) + status = ut_config_type_datasource (&th, option); + else if ((strcasecmp ("WarningMax", option->key) == 0) + || (strcasecmp ("FailureMax", option->key) == 0)) + status = ut_config_type_max (&th, option); + else if ((strcasecmp ("WarningMin", option->key) == 0) + || (strcasecmp ("FailureMin", option->key) == 0)) + status = ut_config_type_min (&th, option); + else if (strcasecmp ("Interesting", option->key) == 0) + status = cf_util_get_flag (option, &th.flags, UT_FLAG_INTERESTING); + else if (strcasecmp ("Invert", option->key) == 0) + status = cf_util_get_flag (option, &th.flags, UT_FLAG_INVERT); + else if (strcasecmp ("Persist", option->key) == 0) + status = cf_util_get_flag (option, &th.flags, UT_FLAG_PERSIST); + else if (strcasecmp ("Percentage", option->key) == 0) + status = cf_util_get_flag (option, &th.flags, UT_FLAG_PERCENTAGE); + else if (strcasecmp ("Hits", option->key) == 0) + status = ut_config_type_hits (&th, option); + else if (strcasecmp ("Hysteresis", option->key) == 0) + status = ut_config_type_hysteresis (&th, option); + else + { + WARNING ("threshold values: Option `%s' not allowed inside a `Type' " + "block.", option->key); + status = -1; + } + + if (status != 0) + break; + } + + if (status == 0) + { + status = ut_threshold_add (&th); + } + + return (status); +} /* int ut_config_type */ + +static int ut_config_plugin_instance (threshold_t *th, oconfig_item_t *ci) +{ + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_STRING)) + { + WARNING ("threshold values: The `Instance' option needs exactly one " + "string argument."); + return (-1); + } + + sstrncpy (th->plugin_instance, ci->values[0].value.string, + sizeof (th->plugin_instance)); + + return (0); +} /* int ut_config_plugin_instance */ + +static int ut_config_plugin (const threshold_t *th_orig, oconfig_item_t *ci) +{ + int i; + threshold_t th; + int status = 0; + + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_STRING)) + { + WARNING ("threshold values: The `Plugin' block needs exactly one string " + "argument."); + return (-1); + } + + if (ci->children_num < 1) + { + WARNING ("threshold values: The `Plugin' block needs at least one nested " + "block."); + return (-1); + } + + memcpy (&th, th_orig, sizeof (th)); + sstrncpy (th.plugin, ci->values[0].value.string, sizeof (th.plugin)); + + for (i = 0; i < ci->children_num; i++) + { + oconfig_item_t *option = ci->children + i; + status = 0; + + if (strcasecmp ("Type", option->key) == 0) + status = ut_config_type (&th, option); + else if (strcasecmp ("Instance", option->key) == 0) + status = ut_config_plugin_instance (&th, option); + else + { + WARNING ("threshold values: Option `%s' not allowed inside a `Plugin' " + "block.", option->key); + status = -1; + } + + if (status != 0) + break; + } + + return (status); +} /* int ut_config_plugin */ + +static int ut_config_host (const threshold_t *th_orig, oconfig_item_t *ci) +{ + int i; + threshold_t th; + int status = 0; + + if ((ci->values_num != 1) + || (ci->values[0].type != OCONFIG_TYPE_STRING)) + { + WARNING ("threshold values: The `Host' block needs exactly one string " + "argument."); + return (-1); + } + + if (ci->children_num < 1) + { + WARNING ("threshold values: The `Host' block needs at least one nested " + "block."); + return (-1); + } + + memcpy (&th, th_orig, sizeof (th)); + sstrncpy (th.host, ci->values[0].value.string, sizeof (th.host)); + + for (i = 0; i < ci->children_num; i++) + { + oconfig_item_t *option = ci->children + i; + status = 0; + + if (strcasecmp ("Type", option->key) == 0) + status = ut_config_type (&th, option); + else if (strcasecmp ("Plugin", option->key) == 0) + status = ut_config_plugin (&th, option); + else + { + WARNING ("threshold values: Option `%s' not allowed inside a `Host' " + "block.", option->key); + status = -1; + } + + if (status != 0) + break; + } + + return (status); +} /* int ut_config_host */ + +int ut_config (oconfig_item_t *ci) +{ + int i; + int status = 0; + + threshold_t th; + + if (ci->values_num != 0) + { + ERROR ("threshold values: The `Threshold' block may not have any " + "arguments."); + return (-1); + } + + if (threshold_tree == NULL) + { + threshold_tree = c_avl_create ((void *) strcmp); + if (threshold_tree == NULL) + { + ERROR ("ut_config: c_avl_create failed."); + return (-1); + } + } + + memset (&th, '\0', sizeof (th)); + th.warning_min = NAN; + th.warning_max = NAN; + th.failure_min = NAN; + th.failure_max = NAN; + + th.hits = 0; + th.hysteresis = 0; + th.flags = UT_FLAG_INTERESTING; /* interesting by default */ + + for (i = 0; i < ci->children_num; i++) + { + oconfig_item_t *option = ci->children + i; + status = 0; + + if (strcasecmp ("Type", option->key) == 0) + status = ut_config_type (&th, option); + else if (strcasecmp ("Plugin", option->key) == 0) + status = ut_config_plugin (&th, option); + else if (strcasecmp ("Host", option->key) == 0) + status = ut_config_host (&th, option); + else + { + WARNING ("threshold values: Option `%s' not allowed here.", option->key); + status = -1; + } + + if (status != 0) + break; + } + + return (status); +} /* int um_config */ +/* + * End of the functions used to configure threshold values. + */ +/* }}} */ + +/* + * int ut_report_state + * + * Checks if the `state' differs from the old state and creates a notification + * if appropriate. + * Does not fail. + */ +static int ut_report_state (const data_set_t *ds, + const value_list_t *vl, + const threshold_t *th, + const gauge_t *values, + int ds_index, + int state) +{ /* {{{ */ + int state_old; + notification_t n; + + char *buf; + size_t bufsize; + + int status; + + /* Check if hits matched */ + if ( (th->hits != 0) ) + { + int hits = uc_get_hits(ds,vl); + /* The STATE_OKAY always reset hits, or if hits reaise the limit */ + if ( (state == STATE_OKAY) || (hits > th->hits) ) + { + DEBUG("ut_report_state: reset uc_get_hits = 0"); + uc_set_hits(ds,vl,0); /* reset hit counter and notify */ + } else { + DEBUG("ut_report_state: th->hits = %d, uc_get_hits = %d",th->hits,uc_get_hits(ds,vl)); + (void) uc_inc_hits(ds,vl,1); /* increase hit counter */ + return (0); + } + } /* end check hits */ + + state_old = uc_get_state (ds, vl); + + /* If the state didn't change, only report if `persistent' is specified and + * the state is not `okay'. */ + if (state == state_old) + { + if ((th->flags & UT_FLAG_PERSIST) == 0) + return (0); + else if (state == STATE_OKAY) + return (0); + } + + if (state != state_old) + uc_set_state (ds, vl, state); + + NOTIFICATION_INIT_VL (&n, vl, ds); + + buf = n.message; + bufsize = sizeof (n.message); + + if (state == STATE_OKAY) + n.severity = NOTIF_OKAY; + else if (state == STATE_WARNING) + n.severity = NOTIF_WARNING; + else + n.severity = NOTIF_FAILURE; + + n.time = vl->time; + + status = ssnprintf (buf, bufsize, "Host %s, plugin %s", + vl->host, vl->plugin); + buf += status; + bufsize -= status; + + if (vl->plugin_instance[0] != '\0') + { + status = ssnprintf (buf, bufsize, " (instance %s)", + vl->plugin_instance); + buf += status; + bufsize -= status; + } + + status = ssnprintf (buf, bufsize, " type %s", vl->type); + buf += status; + bufsize -= status; + + if (vl->type_instance[0] != '\0') + { + status = ssnprintf (buf, bufsize, " (instance %s)", + vl->type_instance); + buf += status; + bufsize -= status; + } + + plugin_notification_meta_add_string (&n, "DataSource", + ds->ds[ds_index].name); + plugin_notification_meta_add_double (&n, "CurrentValue", values[ds_index]); + plugin_notification_meta_add_double (&n, "WarningMin", th->warning_min); + plugin_notification_meta_add_double (&n, "WarningMax", th->warning_max); + plugin_notification_meta_add_double (&n, "FailureMin", th->failure_min); + plugin_notification_meta_add_double (&n, "FailureMax", th->failure_max); + + /* Send an okay notification */ + if (state == STATE_OKAY) + { + if (state_old == STATE_MISSING) + status = ssnprintf (buf, bufsize, + ": Value is no longer missing."); + else + status = ssnprintf (buf, bufsize, + ": All data sources are within range again."); + buf += status; + bufsize -= status; + } + else + { + double min; + double max; + + min = (state == STATE_ERROR) ? th->failure_min : th->warning_min; + max = (state == STATE_ERROR) ? th->failure_max : th->warning_max; + + if (th->flags & UT_FLAG_INVERT) + { + if (!isnan (min) && !isnan (max)) + { + status = ssnprintf (buf, bufsize, ": Data source \"%s\" is currently " + "%f. That is within the %s region of %f%s and %f%s.", + ds->ds[ds_index].name, values[ds_index], + (state == STATE_ERROR) ? "failure" : "warning", + min, ((th->flags & UT_FLAG_PERCENTAGE) != 0) ? "%" : "", + max, ((th->flags & UT_FLAG_PERCENTAGE) != 0) ? "%" : ""); + } + else + { + status = ssnprintf (buf, bufsize, ": Data source \"%s\" is currently " + "%f. That is %s the %s threshold of %f%s.", + ds->ds[ds_index].name, values[ds_index], + isnan (min) ? "below" : "above", + (state == STATE_ERROR) ? "failure" : "warning", + isnan (min) ? max : min, + ((th->flags & UT_FLAG_PERCENTAGE) != 0) ? "%" : ""); + } + } + else /* is not inverted */ + { + status = ssnprintf (buf, bufsize, ": Data source \"%s\" is currently " + "%f. That is %s the %s threshold of %f%s.", + ds->ds[ds_index].name, values[ds_index], + (values[ds_index] < min) ? "below" : "above", + (state == STATE_ERROR) ? "failure" : "warning", + (values[ds_index] < min) ? min : max, + ((th->flags & UT_FLAG_PERCENTAGE) != 0) ? "%" : ""); + } + buf += status; + bufsize -= status; + } + + plugin_dispatch_notification (&n); + + plugin_notification_meta_free (n.meta); + return (0); +} /* }}} int ut_report_state */ + +/* + * int ut_check_one_data_source + * + * Checks one data source against the given threshold configuration. If the + * `DataSource' option is set in the threshold, and the name does NOT match, + * `okay' is returned. If the threshold does match, its failure and warning + * min and max values are checked and `failure' or `warning' is returned if + * appropriate. + * Does not fail. + */ +static int ut_check_one_data_source (const data_set_t *ds, + const value_list_t __attribute__((unused)) *vl, + const threshold_t *th, + const gauge_t *values, + int ds_index) +{ /* {{{ */ + const char *ds_name; + int is_warning = 0; + int is_failure = 0; + int prev_state = STATE_OKAY; + + /* check if this threshold applies to this data source */ + if (ds != NULL) + { + ds_name = ds->ds[ds_index].name; + if ((th->data_source[0] != 0) + && (strcmp (ds_name, th->data_source) != 0)) + return (STATE_OKAY); + } + + if ((th->flags & UT_FLAG_INVERT) != 0) + { + is_warning--; + is_failure--; + } + + /* XXX: This is an experimental code, not optimized, not fast, not reliable, + * and probably, do not work as you expect. Enjoy! :D */ + if ( (th->hysteresis > 0) && ((prev_state = uc_get_state(ds,vl)) != STATE_OKAY) ) + { + switch(prev_state) + { + case STATE_ERROR: + if ( (!isnan (th->failure_min) && ((th->failure_min + th->hysteresis) < values[ds_index])) || + (!isnan (th->failure_max) && ((th->failure_max - th->hysteresis) > values[ds_index])) ) + return (STATE_OKAY); + else + is_failure++; + case STATE_WARNING: + if ( (!isnan (th->warning_min) && ((th->warning_min + th->hysteresis) < values[ds_index])) || + (!isnan (th->warning_max) && ((th->warning_max - th->hysteresis) > values[ds_index])) ) + return (STATE_OKAY); + else + is_warning++; + } + } + else { /* no hysteresis */ + if ((!isnan (th->failure_min) && (th->failure_min > values[ds_index])) + || (!isnan (th->failure_max) && (th->failure_max < values[ds_index]))) + is_failure++; + + if ((!isnan (th->warning_min) && (th->warning_min > values[ds_index])) + || (!isnan (th->warning_max) && (th->warning_max < values[ds_index]))) + is_warning++; + } + + if (is_failure != 0) + return (STATE_ERROR); + + if (is_warning != 0) + return (STATE_WARNING); + + return (STATE_OKAY); +} /* }}} int ut_check_one_data_source */ + +/* + * int ut_check_one_threshold + * + * Checks all data sources of a value list against the given threshold, using + * the ut_check_one_data_source function above. Returns the worst status, + * which is `okay' if nothing has failed. + * Returns less than zero if the data set doesn't have any data sources. + */ +static int ut_check_one_threshold (const data_set_t *ds, + const value_list_t *vl, + const threshold_t *th, + const gauge_t *values, + int *ret_ds_index) +{ /* {{{ */ + int ret = -1; + int ds_index = -1; + int i; + gauge_t values_copy[ds->ds_num]; + + memcpy (values_copy, values, sizeof (values_copy)); + + if ((th->flags & UT_FLAG_PERCENTAGE) != 0) + { + int num = 0; + gauge_t sum=0.0; + + if (ds->ds_num == 1) + { + WARNING ("ut_check_one_threshold: The %s type has only one data " + "source, but you have configured to check this as a percentage. " + "That doesn't make much sense, because the percentage will always " + "be 100%%!", ds->type); + } + + /* Prepare `sum' and `num'. */ + for (i = 0; i < ds->ds_num; i++) + if (!isnan (values[i])) + { + num++; + sum += values[i]; + } + + if ((num == 0) /* All data sources are undefined. */ + || (sum == 0.0)) /* Sum is zero, cannot calculate percentage. */ + { + for (i = 0; i < ds->ds_num; i++) + values_copy[i] = NAN; + } + else /* We can actually calculate the percentage. */ + { + for (i = 0; i < ds->ds_num; i++) + values_copy[i] = 100.0 * values[i] / sum; + } + } /* if (UT_FLAG_PERCENTAGE) */ + + for (i = 0; i < ds->ds_num; i++) + { + int status; + + status = ut_check_one_data_source (ds, vl, th, values_copy, i); + if (ret < status) + { + ret = status; + ds_index = i; + } + } /* for (ds->ds_num) */ + + if (ret_ds_index != NULL) + *ret_ds_index = ds_index; + + return (ret); +} /* }}} int ut_check_one_threshold */ + +/* + * int ut_check_threshold (PUBLIC) + * + * Gets a list of matching thresholds and searches for the worst status by one + * of the thresholds. Then reports that status using the ut_report_state + * function above. + * Returns zero on success and if no threshold has been configured. Returns + * less than zero on failure. + */ +static int ut_check_threshold (const data_set_t *ds, const value_list_t *vl, + __attribute__((unused)) user_data_t *ud) +{ /* {{{ */ + threshold_t *th; + gauge_t *values; + int status; + + int worst_state = -1; + threshold_t *worst_th = NULL; + int worst_ds_index = -1; + + if (threshold_tree == NULL) + return (0); + + /* Is this lock really necessary? So far, thresholds are only inserted at + * startup. -octo */ + pthread_mutex_lock (&threshold_lock); + th = threshold_search (vl); + pthread_mutex_unlock (&threshold_lock); + if (th == NULL) + return (0); + + DEBUG ("ut_check_threshold: Found matching threshold(s)"); + + values = uc_get_rate (ds, vl); + if (values == NULL) + return (0); + + while (th != NULL) + { + int ds_index = -1; + + status = ut_check_one_threshold (ds, vl, th, values, &ds_index); + if (status < 0) + { + ERROR ("ut_check_threshold: ut_check_one_threshold failed."); + sfree (values); + return (-1); + } + + if (worst_state < status) + { + worst_state = status; + worst_th = th; + worst_ds_index = ds_index; + } + + th = th->next; + } /* while (th) */ + + status = ut_report_state (ds, vl, worst_th, values, + worst_ds_index, worst_state); + if (status != 0) + { + ERROR ("ut_check_threshold: ut_report_state failed."); + sfree (values); + return (-1); + } + + sfree (values); + + return (0); +} /* }}} int ut_check_threshold */ + +void module_register (void) +{ + plugin_register_complex_config ("threshold", ut_config); + plugin_register_write ("threshold", ut_check_threshold, + /* user data = */ NULL); +} + +/* vim: set sw=2 ts=8 sts=2 tw=78 et fdm=marker : */ diff --git a/src/utils_cache.c b/src/utils_cache.c index 7e1dcf75..2ed58706 100644 --- a/src/utils_cache.c +++ b/src/utils_cache.c @@ -24,7 +24,6 @@ #include "plugin.h" #include "utils_avltree.h" #include "utils_cache.h" -#include "utils_threshold.h" #include "meta_data.h" #include @@ -436,9 +435,6 @@ int uc_update (const data_set_t *ds, const value_list_t *vl) { char name[6 * DATA_MAX_NAME_LEN]; cache_entry_t *ce = NULL; - int send_okay_notification = 0; - cdtime_t update_delay = 0; - notification_t n; int status; int i; @@ -472,15 +468,6 @@ int uc_update (const data_set_t *ds, const value_list_t *vl) return (-1); } - /* Send a notification (after the lock has been released) if we switch the - * state from something else to `okay'. */ - if (ce->state == STATE_MISSING) - { - send_okay_notification = 1; - ce->state = STATE_OKAY; - update_delay = cdtime () - ce->last_update; - } - for (i = 0; i < ds->ds_num; i++) { switch (ds->ds[i].type) @@ -567,28 +554,6 @@ int uc_update (const data_set_t *ds, const value_list_t *vl) pthread_mutex_unlock (&cache_lock); - if (send_okay_notification == 0) - return (0); - - /* Do not send okay notifications for uninteresting values, i. e. values for - * which no threshold is configured. */ - status = ut_check_interesting (name); - if (status <= 0) - return (0); - - /* Initialize the notification */ - memset (&n, '\0', sizeof (n)); - NOTIFICATION_INIT_VL (&n, vl, ds); - - n.severity = NOTIF_OKAY; - n.time = vl->time; - - ssnprintf (n.message, sizeof (n.message), - "Received a value for %s. It was missing for %u seconds.", - name, (unsigned int) update_delay); - - plugin_dispatch_notification (&n); - return (0); } /* int uc_update */ diff --git a/src/utils_threshold.c b/src/utils_threshold.c deleted file mode 100644 index 99309b93..00000000 --- a/src/utils_threshold.c +++ /dev/null @@ -1,1009 +0,0 @@ -/** - * collectd - src/utils_threshold.c - * Copyright (C) 2007-2009 Florian octo Forster - * Copyright (C) 2008-2009 Sebastian Harl - * Copyright (C) 2009 Andrés J. Díaz - * - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; only version 2 of the License is applicable. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - * - * Author: - * Florian octo Forster - * Sebastian Harl - * Andrés J. Díaz - **/ - -#include "collectd.h" -#include "common.h" -#include "plugin.h" -#include "utils_avltree.h" -#include "utils_cache.h" -#include "utils_threshold.h" - -#include -#include - -/* - * Private data structures - * {{{ */ -#define UT_FLAG_INVERT 0x01 -#define UT_FLAG_PERSIST 0x02 -#define UT_FLAG_PERCENTAGE 0x04 -#define UT_FLAG_INTERESTING 0x08 -/* }}} */ - -/* - * Private (static) variables - * {{{ */ -static c_avl_tree_t *threshold_tree = NULL; -static pthread_mutex_t threshold_lock = PTHREAD_MUTEX_INITIALIZER; -/* }}} */ - -/* - * Threshold management - * ==================== - * The following functions add, delete, search, etc. configured thresholds to - * the underlying AVL trees. - * {{{ */ -static threshold_t *threshold_get (const char *hostname, - const char *plugin, const char *plugin_instance, - const char *type, const char *type_instance) -{ - char name[6 * DATA_MAX_NAME_LEN]; - threshold_t *th = NULL; - - format_name (name, sizeof (name), - (hostname == NULL) ? "" : hostname, - (plugin == NULL) ? "" : plugin, plugin_instance, - (type == NULL) ? "" : type, type_instance); - name[sizeof (name) - 1] = '\0'; - - if (c_avl_get (threshold_tree, name, (void *) &th) == 0) - return (th); - else - return (NULL); -} /* threshold_t *threshold_get */ - -static int ut_threshold_add (const threshold_t *th) -{ - char name[6 * DATA_MAX_NAME_LEN]; - char *name_copy; - threshold_t *th_copy; - threshold_t *th_ptr; - int status = 0; - - if (format_name (name, sizeof (name), th->host, - th->plugin, th->plugin_instance, - th->type, th->type_instance) != 0) - { - ERROR ("ut_threshold_add: format_name failed."); - return (-1); - } - - name_copy = strdup (name); - if (name_copy == NULL) - { - ERROR ("ut_threshold_add: strdup failed."); - return (-1); - } - - th_copy = (threshold_t *) malloc (sizeof (threshold_t)); - if (th_copy == NULL) - { - sfree (name_copy); - ERROR ("ut_threshold_add: malloc failed."); - return (-1); - } - memcpy (th_copy, th, sizeof (threshold_t)); - th_ptr = NULL; - - DEBUG ("ut_threshold_add: Adding entry `%s'", name); - - pthread_mutex_lock (&threshold_lock); - - th_ptr = threshold_get (th->host, th->plugin, th->plugin_instance, - th->type, th->type_instance); - - while ((th_ptr != NULL) && (th_ptr->next != NULL)) - th_ptr = th_ptr->next; - - if (th_ptr == NULL) /* no such threshold yet */ - { - status = c_avl_insert (threshold_tree, name_copy, th_copy); - } - else /* th_ptr points to the last threshold in the list */ - { - th_ptr->next = th_copy; - /* name_copy isn't needed */ - sfree (name_copy); - } - - pthread_mutex_unlock (&threshold_lock); - - if (status != 0) - { - ERROR ("ut_threshold_add: c_avl_insert (%s) failed.", name); - sfree (name_copy); - sfree (th_copy); - } - - return (status); -} /* int ut_threshold_add */ -/* - * End of the threshold management functions - * }}} */ - -/* - * Configuration - * ============= - * The following approximately two hundred functions are used to handle the - * configuration and fill the threshold list. - * {{{ */ -static int ut_config_type_datasource (threshold_t *th, oconfig_item_t *ci) -{ - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_STRING)) - { - WARNING ("threshold values: The `DataSource' option needs exactly one " - "string argument."); - return (-1); - } - - sstrncpy (th->data_source, ci->values[0].value.string, - sizeof (th->data_source)); - - return (0); -} /* int ut_config_type_datasource */ - -static int ut_config_type_instance (threshold_t *th, oconfig_item_t *ci) -{ - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_STRING)) - { - WARNING ("threshold values: The `Instance' option needs exactly one " - "string argument."); - return (-1); - } - - sstrncpy (th->type_instance, ci->values[0].value.string, - sizeof (th->type_instance)); - - return (0); -} /* int ut_config_type_instance */ - -static int ut_config_type_max (threshold_t *th, oconfig_item_t *ci) -{ - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) - { - WARNING ("threshold values: The `%s' option needs exactly one " - "number argument.", ci->key); - return (-1); - } - - if (strcasecmp (ci->key, "WarningMax") == 0) - th->warning_max = ci->values[0].value.number; - else - th->failure_max = ci->values[0].value.number; - - return (0); -} /* int ut_config_type_max */ - -static int ut_config_type_min (threshold_t *th, oconfig_item_t *ci) -{ - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) - { - WARNING ("threshold values: The `%s' option needs exactly one " - "number argument.", ci->key); - return (-1); - } - - if (strcasecmp (ci->key, "WarningMin") == 0) - th->warning_min = ci->values[0].value.number; - else - th->failure_min = ci->values[0].value.number; - - return (0); -} /* int ut_config_type_min */ - -static int ut_config_type_hits (threshold_t *th, oconfig_item_t *ci) -{ - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) - { - WARNING ("threshold values: The `%s' option needs exactly one " - "number argument.", ci->key); - return (-1); - } - - th->hits = ci->values[0].value.number; - - return (0); -} /* int ut_config_type_hits */ - -static int ut_config_type_hysteresis (threshold_t *th, oconfig_item_t *ci) -{ - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) - { - WARNING ("threshold values: The `%s' option needs exactly one " - "number argument.", ci->key); - return (-1); - } - - th->hysteresis = ci->values[0].value.number; - - return (0); -} /* int ut_config_type_hysteresis */ - -static int ut_config_type (const threshold_t *th_orig, oconfig_item_t *ci) -{ - int i; - threshold_t th; - int status = 0; - - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_STRING)) - { - WARNING ("threshold values: The `Type' block needs exactly one string " - "argument."); - return (-1); - } - - if (ci->children_num < 1) - { - WARNING ("threshold values: The `Type' block needs at least one option."); - return (-1); - } - - memcpy (&th, th_orig, sizeof (th)); - sstrncpy (th.type, ci->values[0].value.string, sizeof (th.type)); - - th.warning_min = NAN; - th.warning_max = NAN; - th.failure_min = NAN; - th.failure_max = NAN; - th.hits = 0; - th.hysteresis = 0; - th.flags = UT_FLAG_INTERESTING; /* interesting by default */ - - for (i = 0; i < ci->children_num; i++) - { - oconfig_item_t *option = ci->children + i; - status = 0; - - if (strcasecmp ("Instance", option->key) == 0) - status = ut_config_type_instance (&th, option); - else if (strcasecmp ("DataSource", option->key) == 0) - status = ut_config_type_datasource (&th, option); - else if ((strcasecmp ("WarningMax", option->key) == 0) - || (strcasecmp ("FailureMax", option->key) == 0)) - status = ut_config_type_max (&th, option); - else if ((strcasecmp ("WarningMin", option->key) == 0) - || (strcasecmp ("FailureMin", option->key) == 0)) - status = ut_config_type_min (&th, option); - else if (strcasecmp ("Interesting", option->key) == 0) - status = cf_util_get_flag (option, &th.flags, UT_FLAG_INTERESTING); - else if (strcasecmp ("Invert", option->key) == 0) - status = cf_util_get_flag (option, &th.flags, UT_FLAG_INVERT); - else if (strcasecmp ("Persist", option->key) == 0) - status = cf_util_get_flag (option, &th.flags, UT_FLAG_PERSIST); - else if (strcasecmp ("Percentage", option->key) == 0) - status = cf_util_get_flag (option, &th.flags, UT_FLAG_PERCENTAGE); - else if (strcasecmp ("Hits", option->key) == 0) - status = ut_config_type_hits (&th, option); - else if (strcasecmp ("Hysteresis", option->key) == 0) - status = ut_config_type_hysteresis (&th, option); - else - { - WARNING ("threshold values: Option `%s' not allowed inside a `Type' " - "block.", option->key); - status = -1; - } - - if (status != 0) - break; - } - - if (status == 0) - { - status = ut_threshold_add (&th); - } - - return (status); -} /* int ut_config_type */ - -static int ut_config_plugin_instance (threshold_t *th, oconfig_item_t *ci) -{ - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_STRING)) - { - WARNING ("threshold values: The `Instance' option needs exactly one " - "string argument."); - return (-1); - } - - sstrncpy (th->plugin_instance, ci->values[0].value.string, - sizeof (th->plugin_instance)); - - return (0); -} /* int ut_config_plugin_instance */ - -static int ut_config_plugin (const threshold_t *th_orig, oconfig_item_t *ci) -{ - int i; - threshold_t th; - int status = 0; - - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_STRING)) - { - WARNING ("threshold values: The `Plugin' block needs exactly one string " - "argument."); - return (-1); - } - - if (ci->children_num < 1) - { - WARNING ("threshold values: The `Plugin' block needs at least one nested " - "block."); - return (-1); - } - - memcpy (&th, th_orig, sizeof (th)); - sstrncpy (th.plugin, ci->values[0].value.string, sizeof (th.plugin)); - - for (i = 0; i < ci->children_num; i++) - { - oconfig_item_t *option = ci->children + i; - status = 0; - - if (strcasecmp ("Type", option->key) == 0) - status = ut_config_type (&th, option); - else if (strcasecmp ("Instance", option->key) == 0) - status = ut_config_plugin_instance (&th, option); - else - { - WARNING ("threshold values: Option `%s' not allowed inside a `Plugin' " - "block.", option->key); - status = -1; - } - - if (status != 0) - break; - } - - return (status); -} /* int ut_config_plugin */ - -static int ut_config_host (const threshold_t *th_orig, oconfig_item_t *ci) -{ - int i; - threshold_t th; - int status = 0; - - if ((ci->values_num != 1) - || (ci->values[0].type != OCONFIG_TYPE_STRING)) - { - WARNING ("threshold values: The `Host' block needs exactly one string " - "argument."); - return (-1); - } - - if (ci->children_num < 1) - { - WARNING ("threshold values: The `Host' block needs at least one nested " - "block."); - return (-1); - } - - memcpy (&th, th_orig, sizeof (th)); - sstrncpy (th.host, ci->values[0].value.string, sizeof (th.host)); - - for (i = 0; i < ci->children_num; i++) - { - oconfig_item_t *option = ci->children + i; - status = 0; - - if (strcasecmp ("Type", option->key) == 0) - status = ut_config_type (&th, option); - else if (strcasecmp ("Plugin", option->key) == 0) - status = ut_config_plugin (&th, option); - else - { - WARNING ("threshold values: Option `%s' not allowed inside a `Host' " - "block.", option->key); - status = -1; - } - - if (status != 0) - break; - } - - return (status); -} /* int ut_config_host */ - -int ut_config (const oconfig_item_t *ci) -{ - int i; - int status = 0; - - threshold_t th; - - if (ci->values_num != 0) - { - ERROR ("threshold values: The `Threshold' block may not have any " - "arguments."); - return (-1); - } - - if (threshold_tree == NULL) - { - threshold_tree = c_avl_create ((void *) strcmp); - if (threshold_tree == NULL) - { - ERROR ("ut_config: c_avl_create failed."); - return (-1); - } - } - - memset (&th, '\0', sizeof (th)); - th.warning_min = NAN; - th.warning_max = NAN; - th.failure_min = NAN; - th.failure_max = NAN; - - th.hits = 0; - th.hysteresis = 0; - th.flags = UT_FLAG_INTERESTING; /* interesting by default */ - - for (i = 0; i < ci->children_num; i++) - { - oconfig_item_t *option = ci->children + i; - status = 0; - - if (strcasecmp ("Type", option->key) == 0) - status = ut_config_type (&th, option); - else if (strcasecmp ("Plugin", option->key) == 0) - status = ut_config_plugin (&th, option); - else if (strcasecmp ("Host", option->key) == 0) - status = ut_config_host (&th, option); - else - { - WARNING ("threshold values: Option `%s' not allowed here.", option->key); - status = -1; - } - - if (status != 0) - break; - } - - return (status); -} /* int um_config */ -/* - * End of the functions used to configure threshold values. - */ -/* }}} */ - -static threshold_t *threshold_search (const value_list_t *vl) -{ - threshold_t *th; - - if ((th = threshold_get (vl->host, vl->plugin, vl->plugin_instance, - vl->type, vl->type_instance)) != NULL) - return (th); - else if ((th = threshold_get (vl->host, vl->plugin, vl->plugin_instance, - vl->type, NULL)) != NULL) - return (th); - else if ((th = threshold_get (vl->host, vl->plugin, NULL, - vl->type, vl->type_instance)) != NULL) - return (th); - else if ((th = threshold_get (vl->host, vl->plugin, NULL, - vl->type, NULL)) != NULL) - return (th); - else if ((th = threshold_get (vl->host, "", NULL, - vl->type, vl->type_instance)) != NULL) - return (th); - else if ((th = threshold_get (vl->host, "", NULL, - vl->type, NULL)) != NULL) - return (th); - else if ((th = threshold_get ("", vl->plugin, vl->plugin_instance, - vl->type, vl->type_instance)) != NULL) - return (th); - else if ((th = threshold_get ("", vl->plugin, vl->plugin_instance, - vl->type, NULL)) != NULL) - return (th); - else if ((th = threshold_get ("", vl->plugin, NULL, - vl->type, vl->type_instance)) != NULL) - return (th); - else if ((th = threshold_get ("", vl->plugin, NULL, - vl->type, NULL)) != NULL) - return (th); - else if ((th = threshold_get ("", "", NULL, - vl->type, vl->type_instance)) != NULL) - return (th); - else if ((th = threshold_get ("", "", NULL, - vl->type, NULL)) != NULL) - return (th); - - return (NULL); -} /* threshold_t *threshold_search */ - -/* - * int ut_report_state - * - * Checks if the `state' differs from the old state and creates a notification - * if appropriate. - * Does not fail. - */ -static int ut_report_state (const data_set_t *ds, - const value_list_t *vl, - const threshold_t *th, - const gauge_t *values, - int ds_index, - int state) -{ /* {{{ */ - int state_old; - notification_t n; - - char *buf; - size_t bufsize; - - int status; - - /* Check if hits matched */ - if ( (th->hits != 0) ) - { - int hits = uc_get_hits(ds,vl); - /* The STATE_OKAY always reset hits, or if hits reaise the limit */ - if ( (state == STATE_OKAY) || (hits > th->hits) ) - { - DEBUG("ut_report_state: reset uc_get_hits = 0"); - uc_set_hits(ds,vl,0); /* reset hit counter and notify */ - } else { - DEBUG("ut_report_state: th->hits = %d, uc_get_hits = %d",th->hits,uc_get_hits(ds,vl)); - (void) uc_inc_hits(ds,vl,1); /* increase hit counter */ - return (0); - } - } /* end check hits */ - - state_old = uc_get_state (ds, vl); - - /* If the state didn't change, only report if `persistent' is specified and - * the state is not `okay'. */ - if (state == state_old) - { - if ((th->flags & UT_FLAG_PERSIST) == 0) - return (0); - else if (state == STATE_OKAY) - return (0); - } - - if (state != state_old) - uc_set_state (ds, vl, state); - - NOTIFICATION_INIT_VL (&n, vl, ds); - - buf = n.message; - bufsize = sizeof (n.message); - - if (state == STATE_OKAY) - n.severity = NOTIF_OKAY; - else if (state == STATE_WARNING) - n.severity = NOTIF_WARNING; - else - n.severity = NOTIF_FAILURE; - - n.time = vl->time; - - status = ssnprintf (buf, bufsize, "Host %s, plugin %s", - vl->host, vl->plugin); - buf += status; - bufsize -= status; - - if (vl->plugin_instance[0] != '\0') - { - status = ssnprintf (buf, bufsize, " (instance %s)", - vl->plugin_instance); - buf += status; - bufsize -= status; - } - - status = ssnprintf (buf, bufsize, " type %s", vl->type); - buf += status; - bufsize -= status; - - if (vl->type_instance[0] != '\0') - { - status = ssnprintf (buf, bufsize, " (instance %s)", - vl->type_instance); - buf += status; - bufsize -= status; - } - - plugin_notification_meta_add_string (&n, "DataSource", - ds->ds[ds_index].name); - plugin_notification_meta_add_double (&n, "CurrentValue", values[ds_index]); - plugin_notification_meta_add_double (&n, "WarningMin", th->warning_min); - plugin_notification_meta_add_double (&n, "WarningMax", th->warning_max); - plugin_notification_meta_add_double (&n, "FailureMin", th->failure_min); - plugin_notification_meta_add_double (&n, "FailureMax", th->failure_max); - - /* Send an okay notification */ - if (state == STATE_OKAY) - { - status = ssnprintf (buf, bufsize, ": All data sources are within range again."); - buf += status; - bufsize -= status; - } - else - { - double min; - double max; - - min = (state == STATE_ERROR) ? th->failure_min : th->warning_min; - max = (state == STATE_ERROR) ? th->failure_max : th->warning_max; - - if (th->flags & UT_FLAG_INVERT) - { - if (!isnan (min) && !isnan (max)) - { - status = ssnprintf (buf, bufsize, ": Data source \"%s\" is currently " - "%f. That is within the %s region of %f%s and %f%s.", - ds->ds[ds_index].name, values[ds_index], - (state == STATE_ERROR) ? "failure" : "warning", - min, ((th->flags & UT_FLAG_PERCENTAGE) != 0) ? "%" : "", - max, ((th->flags & UT_FLAG_PERCENTAGE) != 0) ? "%" : ""); - } - else - { - status = ssnprintf (buf, bufsize, ": Data source \"%s\" is currently " - "%f. That is %s the %s threshold of %f%s.", - ds->ds[ds_index].name, values[ds_index], - isnan (min) ? "below" : "above", - (state == STATE_ERROR) ? "failure" : "warning", - isnan (min) ? max : min, - ((th->flags & UT_FLAG_PERCENTAGE) != 0) ? "%" : ""); - } - } - else /* is not inverted */ - { - status = ssnprintf (buf, bufsize, ": Data source \"%s\" is currently " - "%f. That is %s the %s threshold of %f%s.", - ds->ds[ds_index].name, values[ds_index], - (values[ds_index] < min) ? "below" : "above", - (state == STATE_ERROR) ? "failure" : "warning", - (values[ds_index] < min) ? min : max, - ((th->flags & UT_FLAG_PERCENTAGE) != 0) ? "%" : ""); - } - buf += status; - bufsize -= status; - } - - plugin_dispatch_notification (&n); - - plugin_notification_meta_free (n.meta); - return (0); -} /* }}} int ut_report_state */ - -/* - * int ut_check_one_data_source - * - * Checks one data source against the given threshold configuration. If the - * `DataSource' option is set in the threshold, and the name does NOT match, - * `okay' is returned. If the threshold does match, its failure and warning - * min and max values are checked and `failure' or `warning' is returned if - * appropriate. - * Does not fail. - */ -static int ut_check_one_data_source (const data_set_t *ds, - const value_list_t __attribute__((unused)) *vl, - const threshold_t *th, - const gauge_t *values, - int ds_index) -{ /* {{{ */ - const char *ds_name; - int is_warning = 0; - int is_failure = 0; - int prev_state = STATE_OKAY; - - /* check if this threshold applies to this data source */ - if (ds != NULL) - { - ds_name = ds->ds[ds_index].name; - if ((th->data_source[0] != 0) - && (strcmp (ds_name, th->data_source) != 0)) - return (STATE_OKAY); - } - - if ((th->flags & UT_FLAG_INVERT) != 0) - { - is_warning--; - is_failure--; - } - - /* XXX: This is an experimental code, not optimized, not fast, not reliable, - * and probably, do not work as you expect. Enjoy! :D */ - if ( (th->hysteresis > 0) && ((prev_state = uc_get_state(ds,vl)) != STATE_OKAY) ) - { - switch(prev_state) - { - case STATE_ERROR: - if ( (!isnan (th->failure_min) && ((th->failure_min + th->hysteresis) < values[ds_index])) || - (!isnan (th->failure_max) && ((th->failure_max - th->hysteresis) > values[ds_index])) ) - return (STATE_OKAY); - else - is_failure++; - case STATE_WARNING: - if ( (!isnan (th->warning_min) && ((th->warning_min + th->hysteresis) < values[ds_index])) || - (!isnan (th->warning_max) && ((th->warning_max - th->hysteresis) > values[ds_index])) ) - return (STATE_OKAY); - else - is_warning++; - } - } - else { /* no hysteresis */ - if ((!isnan (th->failure_min) && (th->failure_min > values[ds_index])) - || (!isnan (th->failure_max) && (th->failure_max < values[ds_index]))) - is_failure++; - - if ((!isnan (th->warning_min) && (th->warning_min > values[ds_index])) - || (!isnan (th->warning_max) && (th->warning_max < values[ds_index]))) - is_warning++; - } - - if (is_failure != 0) - return (STATE_ERROR); - - if (is_warning != 0) - return (STATE_WARNING); - - return (STATE_OKAY); -} /* }}} int ut_check_one_data_source */ - -/* - * int ut_check_one_threshold - * - * Checks all data sources of a value list against the given threshold, using - * the ut_check_one_data_source function above. Returns the worst status, - * which is `okay' if nothing has failed. - * Returns less than zero if the data set doesn't have any data sources. - */ -static int ut_check_one_threshold (const data_set_t *ds, - const value_list_t *vl, - const threshold_t *th, - const gauge_t *values, - int *ret_ds_index) -{ /* {{{ */ - int ret = -1; - int ds_index = -1; - int i; - gauge_t values_copy[ds->ds_num]; - - memcpy (values_copy, values, sizeof (values_copy)); - - if ((th->flags & UT_FLAG_PERCENTAGE) != 0) - { - int num = 0; - gauge_t sum=0.0; - - if (ds->ds_num == 1) - { - WARNING ("ut_check_one_threshold: The %s type has only one data " - "source, but you have configured to check this as a percentage. " - "That doesn't make much sense, because the percentage will always " - "be 100%%!", ds->type); - } - - /* Prepare `sum' and `num'. */ - for (i = 0; i < ds->ds_num; i++) - if (!isnan (values[i])) - { - num++; - sum += values[i]; - } - - if ((num == 0) /* All data sources are undefined. */ - || (sum == 0.0)) /* Sum is zero, cannot calculate percentage. */ - { - for (i = 0; i < ds->ds_num; i++) - values_copy[i] = NAN; - } - else /* We can actually calculate the percentage. */ - { - for (i = 0; i < ds->ds_num; i++) - values_copy[i] = 100.0 * values[i] / sum; - } - } /* if (UT_FLAG_PERCENTAGE) */ - - for (i = 0; i < ds->ds_num; i++) - { - int status; - - status = ut_check_one_data_source (ds, vl, th, values_copy, i); - if (ret < status) - { - ret = status; - ds_index = i; - } - } /* for (ds->ds_num) */ - - if (ret_ds_index != NULL) - *ret_ds_index = ds_index; - - return (ret); -} /* }}} int ut_check_one_threshold */ - -/* - * int ut_check_threshold (PUBLIC) - * - * Gets a list of matching thresholds and searches for the worst status by one - * of the thresholds. Then reports that status using the ut_report_state - * function above. - * Returns zero on success and if no threshold has been configured. Returns - * less than zero on failure. - */ -int ut_check_threshold (const data_set_t *ds, const value_list_t *vl) -{ /* {{{ */ - threshold_t *th; - gauge_t *values; - int status; - - int worst_state = -1; - threshold_t *worst_th = NULL; - int worst_ds_index = -1; - - if (threshold_tree == NULL) - return (0); - - /* Is this lock really necessary? So far, thresholds are only inserted at - * startup. -octo */ - pthread_mutex_lock (&threshold_lock); - th = threshold_search (vl); - pthread_mutex_unlock (&threshold_lock); - if (th == NULL) - return (0); - - DEBUG ("ut_check_threshold: Found matching threshold(s)"); - - values = uc_get_rate (ds, vl); - if (values == NULL) - return (0); - - while (th != NULL) - { - int ds_index = -1; - - status = ut_check_one_threshold (ds, vl, th, values, &ds_index); - if (status < 0) - { - ERROR ("ut_check_threshold: ut_check_one_threshold failed."); - sfree (values); - return (-1); - } - - if (worst_state < status) - { - worst_state = status; - worst_th = th; - worst_ds_index = ds_index; - } - - th = th->next; - } /* while (th) */ - - status = ut_report_state (ds, vl, worst_th, values, - worst_ds_index, worst_state); - if (status != 0) - { - ERROR ("ut_check_threshold: ut_report_state failed."); - sfree (values); - return (-1); - } - - sfree (values); - - return (0); -} /* }}} int ut_check_threshold */ - -/* - * int ut_check_interesting (PUBLIC) - * - * Given an identification returns - * 0: No threshold is defined. - * 1: A threshold has been found. The flag `persist' is off. - * 2: A threshold has been found. The flag `persist' is on. - * (That is, it is expected that many notifications are sent until the - * problem disappears.) - */ -int ut_check_interesting (const char *name) -{ /* {{{ */ - char *name_copy = NULL; - char *host = NULL; - char *plugin = NULL; - char *plugin_instance = NULL; - char *type = NULL; - char *type_instance = NULL; - int status; - data_set_t ds; - value_list_t vl; - threshold_t *th; - - /* If there is no tree nothing is interesting. */ - if (threshold_tree == NULL) - return (0); - - name_copy = strdup (name); - if (name_copy == NULL) - { - ERROR ("ut_check_interesting: strdup failed."); - return (-1); - } - - status = parse_identifier (name_copy, &host, - &plugin, &plugin_instance, &type, &type_instance); - if (status != 0) - { - ERROR ("ut_check_interesting: parse_identifier failed."); - sfree (name_copy); - return (-1); - } - - memset (&ds, '\0', sizeof (ds)); - memset (&vl, '\0', sizeof (vl)); - - sstrncpy (vl.host, host, sizeof (vl.host)); - sstrncpy (vl.plugin, plugin, sizeof (vl.plugin)); - if (plugin_instance != NULL) - sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance)); - sstrncpy (ds.type, type, sizeof (ds.type)); - sstrncpy (vl.type, type, sizeof (vl.type)); - if (type_instance != NULL) - sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance)); - - sfree (name_copy); - host = plugin = plugin_instance = type = type_instance = NULL; - - th = threshold_search (&vl); - if (th == NULL) - return (0); - - if ((th->flags & UT_FLAG_INTERESTING) == 0) - return (0); - - if ((th->flags & UT_FLAG_PERSIST) == 0) - return (1); - return (2); -} /* }}} int ut_check_interesting */ - -int ut_search_threshold (const value_list_t *vl, /* {{{ */ - threshold_t *ret_threshold) -{ - threshold_t *t; - - if (vl == NULL) - return (EINVAL); - - t = threshold_search (vl); - if (t == NULL) - return (ENOENT); - - memcpy (ret_threshold, t, sizeof (*ret_threshold)); - ret_threshold->next = NULL; - - return (0); -} /* }}} int ut_search_threshold */ - -/* vim: set sw=2 ts=8 sts=2 tw=78 et fdm=marker : */ diff --git a/src/utils_threshold.h b/src/utils_threshold.h deleted file mode 100644 index 5955ca6e..00000000 --- a/src/utils_threshold.h +++ /dev/null @@ -1,87 +0,0 @@ -/** - * collectd - src/utils_threshold.h - * Copyright (C) 2007-2009 Florian octo Forster - * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation; only version 2 of the License is applicable. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - * - * Author: - * Florian octo Forster - **/ - -#ifndef UTILS_THRESHOLD_H -#define UTILS_THRESHOLD_H 1 - -#include "collectd.h" -#include "liboconfig/oconfig.h" -#include "plugin.h" - -typedef struct threshold_s -{ - char host[DATA_MAX_NAME_LEN]; - char plugin[DATA_MAX_NAME_LEN]; - char plugin_instance[DATA_MAX_NAME_LEN]; - char type[DATA_MAX_NAME_LEN]; - char type_instance[DATA_MAX_NAME_LEN]; - char data_source[DATA_MAX_NAME_LEN]; - gauge_t warning_min; - gauge_t warning_max; - gauge_t failure_min; - gauge_t failure_max; - gauge_t hysteresis; - unsigned int flags; - int hits; - struct threshold_s *next; -} threshold_t; - -/* - * ut_config - * - * Parses the configuration and sets up the module. This is called from - * `src/configfile.c'. - */ -int ut_config (const oconfig_item_t *ci); - -/* - * ut_check_threshold - * - * Checks if a threshold is defined for this value and if such a threshold is - * configured, check if the value within the acceptable range. If it is not, a - * notification is dispatched to inform the user that a problem exists. This is - * called from `plugin_read_all'. - */ -int ut_check_threshold (const data_set_t *ds, const value_list_t *vl); - -/* - * Given an identification returns - * 0: No threshold is defined. - * 1: A threshold has been found. The flag `persist' is off. - * 2: A threshold has been found. The flag `persist' is on. - * (That is, it is expected that many notifications are sent until the - * problem disappears.) - */ -int ut_check_interesting (const char *name); - -/* - * Given an identifier in form of a `value_list_t', searches for the best - * matching threshold configuration. `ret_threshold' may be NULL. - * - * Returns: - * 0: Success. Threshold configuration has been copied to - * `ret_threshold' (if it is non-NULL). - * ENOENT: No configuration for this identifier found. - * else: Error. - */ -int ut_search_threshold (const value_list_t *vl, threshold_t *ret_threshold); - -#endif /* UTILS_THRESHOLD_H */