* 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
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])
teamspeak2 . . . . . $enable_teamspeak2
ted . . . . . . . . . $enable_ted
thermal . . . . . . . $enable_thermal
+ threshold . . . . . . $enable_threshold
tokyotyrant . . . . . $enable_tokyotyrant
unixsock . . . . . . $enable_unixsock
uptime . . . . . . . $enable_uptime
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
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
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
collectd-perl.5 \
collectd-python.5 \
collectd-snmp.5 \
+ collectd-threshold.5 \
collectd-unixsock.5 \
types.db.5
collectd-python.pod \
collectd.pod \
collectd-snmp.pod \
+ collectd-threshold.pod \
collectd-unixsock.pod \
postgresql_default.conf \
types.db.pod
--- /dev/null
+=head1 NAME
+
+collectd-threshold - Documentation of collectd's I<Threshold plugin>
+
+=head1 SYNOPSIS
+
+ LoadPlugin "threshold"
+ <Plugin "threshold">
+ <Type "foo">
+ WarningMin 0.00
+ WarningMax 1000.00
+ FailureMin 0.00
+ FailureMax 1200.00
+ Invert false
+ Instance "bar"
+ </Type>
+ </Plugin>
+
+=head1 DESCRIPTION
+
+Starting with version C<4.3.0> I<collectd> has support for B<monitoring>. 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<Threshold plugin> takes itself is to generate and dispatch a
+I<notification>. 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<thresholds> 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<Timeout> iterations. The B<Timeout> configuration option is
+explained in section L<collectd.conf(5)/"GLOBAL OPTIONS">. If, for example,
+B<Timeout> 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<Interval> 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"
+ <Plugin "threshold">
+ <Type "foo">
+ WarningMin 0.00
+ WarningMax 1000.00
+ FailureMin 0.00
+ FailureMax 1200.00
+ Invert false
+ Instance "bar"
+ </Type>
+
+ <Plugin "interface">
+ Instance "eth0"
+ <Type "if_octets">
+ FailureMax 10000000
+ DataSource "rx"
+ </Type>
+ </Plugin>
+
+ <Host "hostname">
+ <Type "cpu">
+ Instance "idle"
+ FailureMin 10
+ </Type>
+
+ <Plugin "memory">
+ <Type "memory">
+ Instance "cached"
+ WarningMin 100000000
+ </Type>
+ </Plugin>
+
+ <Type "load">
+ DataSource "midterm"
+ FailureMax 4
+ Hits 3
+ Hysteresis 3
+ </Type>
+ </Host>
+ </Plugin>
+
+There are basically two types of configuration statements: The C<Host>,
+C<Plugin>, and C<Type> blocks select the value for which a threshold should be
+configured. The C<Plugin> and C<Type> blocks may be specified further using the
+C<Instance> option. You can combine the block by nesting the blocks, though
+they must be nested in the above order, i.e. C<Host> may contain either
+C<Plugin> and C<Type> blocks, C<Plugin> may only contain C<Type> blocks and
+C<Type> 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<must> be
+included in a C<Type> block. Currently the following statements are recognized:
+
+=over 4
+
+=item B<FailureMax> I<Value>
+
+=item B<WarningMax> I<Value>
+
+Sets the upper bound of acceptable values. If unset defaults to positive
+infinity. If a value is greater than B<FailureMax> a B<FAILURE> notification
+will be created. If the value is greater than B<WarningMax> but less than (or
+equal to) B<FailureMax> a B<WARNING> notification will be created.
+
+=item B<FailureMin> I<Value>
+
+=item B<WarningMin> I<Value>
+
+Sets the lower bound of acceptable values. If unset defaults to negative
+infinity. If a value is less than B<FailureMin> a B<FAILURE> notification will
+be created. If the value is less than B<WarningMin> but greater than (or equal
+to) B<FailureMin> a B<WARNING> notification will be created.
+
+=item B<DataSource> I<DSName>
+
+Some data sets have more than one "data source". Interesting examples are the
+C<if_octets> data set, which has received (C<rx>) and sent (C<tx>) bytes and
+the C<disk_ops> data set, which holds C<read> and C<write> operations. The
+system load data set, C<load>, even has three data sources: C<shortterm>,
+C<midterm>, and C<longterm>.
+
+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<DataSource> option to have a threshold apply only to
+one data source.
+
+=item B<Invert> B<true>|B<false>
+
+If set to B<true> the range of acceptable values is inverted, i.e. values
+between B<FailureMin> and B<FailureMax> (B<WarningMin> and B<WarningMax>) are
+not okay. Defaults to B<false>.
+
+=item B<Persist> B<true>|B<false>
+
+Sets how often notifications are generated. If set to B<true> one notification
+will be generated for each value that is out of the acceptable range. If set to
+B<false> (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<true> a notification about a
+missing value is generated once every B<Interval> seconds. If set to B<false>
+only one such notification is generated until the value appears again.
+
+=item B<Percentage> B<true>|B<false>
+
+If set to B<true>, 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<nbsp>% of the total space is available. Defaults to B<false>.
+
+=item B<Hits> I<Value>
+
+Sets the number of occurrences which the threshold must be raised before to
+dispatch any notification or, in other words, the number of B<Interval>s
+that the threshold must be match before dispatch any notification.
+
+=item B<Hysteresis> I<Value>
+
+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<WarningMax>, B<FailureMin> or
+everything else) minus the hysteresis value, the failure (respectively warning)
+state will be keep.
+
+=item B<Interesting> B<true>|B<false>
+
+If set to B<true> (the default), the threshold must be treated as interesting
+and, when a number of B<Timeout> values will lost, then a missing notification
+will be dispatched. On the other hand, if set to B<false>, the missing
+notification will never dispatched for this threshold.
+
+=back
+
+=head1 SEE ALSO
+
+L<collectd(1)>,
+L<collectd.conf(5)>
+
+=head1 AUTHOR
+
+Florian Forster E<lt>octoE<nbsp>atE<nbsp>collectd.orgE<gt>
#<Chain "PostCache">
# Target "write"
#</Chain>
+
+##############################################################################
+# 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"
+#<Plugin "threshold">
+# <Type "foo">
+# WarningMin 0.00
+# WarningMax 1000.00
+# FailureMin 0.00
+# FailureMax 1200.00
+# Invert false
+# Instance "bar"
+# </Type>
+#
+# <Plugin "interface">
+# Instance "eth0"
+# <Type "if_octets">
+# FailureMax 10000000
+# DataSource "rx"
+# </Type>
+# </Plugin>
+#
+# <Host "hostname">
+# <Type "cpu">
+# Instance "idle"
+# FailureMin 10
+# </Type>
+#
+# <Plugin "memory">
+# <Type "memory">
+# Instance "cached"
+# WarningMin 100000000
+# </Type>
+# </Plugin>
+#
+# <Type "load">
+# DataSource "midterm"
+# FailureMax 4
+# Hits 3
+# Hysteresis 3
+# </Type>
+# </Host>
+#</Plugin>
this setting uses iterations, the maximum allowed time without update depends
on the I<Interval> information contained in each value list. This is used in
the I<Threshold> configuration to dispatch notifications about missing values,
-see L<"THRESHOLD CONFIGURATION"> below.
+see L<collectd-threshold(5)> for details.
=item B<ReadThreads> I<Num>
=item B<ForceUseProcfs> I<true>|I<false>
-By default, the C<thermal> plugin tries to read the statistics from the Linux
+By default, the I<Thermal plugin> tries to read the statistics from the Linux
C<sysfs> interface. If that is not available, the plugin falls back to the
C<procfs> interface. By setting this option to I<true>, you can force the
plugin to use the latter. This option defaults to I<false>.
=back
+=head2 Plugin C<threshold>
+
+The I<Threshold plugin> checks values collected or received by I<collectd>
+against a configurable I<threshold> and issues I<notifications> if values are
+out of bounds.
+
+Documentation for this plugin is available in the L<collectd-threshold(5)>
+manual page.
+
=head2 Plugin C<tokyotyrant>
-The C<tokyotyrant plugin> connects to a TokyoTyrant server and collects a
+The I<TokyoTyrant plugin> connects to a TokyoTyrant server and collects a
couple metrics: number of records, and database size on disk.
=over 4
=back
-=head1 THRESHOLD CONFIGURATION
-
-Starting with version C<4.3.0> collectd has support for B<monitoring>. 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<thresholds> 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<Timeout> iterations. The B<Timeout> configuration option is
-explained in section L<"GLOBAL OPTIONS">. If, for example, B<Timeout> 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<Interval>
-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.
-
- <Threshold>
- <Type "foo">
- WarningMin 0.00
- WarningMax 1000.00
- FailureMin 0.00
- FailureMax 1200.00
- Invert false
- Instance "bar"
- </Type>
-
- <Plugin "interface">
- Instance "eth0"
- <Type "if_octets">
- FailureMax 10000000
- DataSource "rx"
- </Type>
- </Plugin>
-
- <Host "hostname">
- <Type "cpu">
- Instance "idle"
- FailureMin 10
- </Type>
-
- <Plugin "memory">
- <Type "memory">
- Instance "cached"
- WarningMin 100000000
- </Type>
- </Plugin>
-
- <Type "load">
- DataSource "midterm"
- FailureMax 4
- Hits 3
- Hysteresis 3
- </Type>
- </Host>
- </Threshold>
-
-There are basically two types of configuration statements: The C<Host>,
-C<Plugin>, and C<Type> blocks select the value for which a threshold should be
-configured. The C<Plugin> and C<Type> blocks may be specified further using the
-C<Instance> option. You can combine the block by nesting the blocks, though
-they must be nested in the above order, i.E<nbsp>e. C<Host> may contain either
-C<Plugin> and C<Type> blocks, C<Plugin> may only contain C<Type> blocks and
-C<Type> 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<must> be
-included in a C<Type> block. Currently the following statements are recognized:
-
-=over 4
-
-=item B<FailureMax> I<Value>
-
-=item B<WarningMax> I<Value>
-
-Sets the upper bound of acceptable values. If unset defaults to positive
-infinity. If a value is greater than B<FailureMax> a B<FAILURE> notification
-will be created. If the value is greater than B<WarningMax> but less than (or
-equal to) B<FailureMax> a B<WARNING> notification will be created.
-
-=item B<FailureMin> I<Value>
-
-=item B<WarningMin> I<Value>
-
-Sets the lower bound of acceptable values. If unset defaults to negative
-infinity. If a value is less than B<FailureMin> a B<FAILURE> notification will
-be created. If the value is less than B<WarningMin> but greater than (or equal
-to) B<FailureMin> a B<WARNING> notification will be created.
-
-=item B<DataSource> I<DSName>
-
-Some data sets have more than one "data source". Interesting examples are the
-C<if_octets> data set, which has received (C<rx>) and sent (C<tx>) bytes and
-the C<disk_ops> data set, which holds C<read> and C<write> operations. The
-system load data set, C<load>, even has three data sources: C<shortterm>,
-C<midterm>, and C<longterm>.
-
-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<DataSource> option to have a threshold apply only to
-one data source.
-
-=item B<Invert> B<true>|B<false>
-
-If set to B<true> the range of acceptable values is inverted, i.E<nbsp>e.
-values between B<FailureMin> and B<FailureMax> (B<WarningMin> and
-B<WarningMax>) are not okay. Defaults to B<false>.
-
-=item B<Persist> B<true>|B<false>
-
-Sets how often notifications are generated. If set to B<true> one notification
-will be generated for each value that is out of the acceptable range. If set to
-B<false> (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<true> a notification about a
-missing value is generated once every B<Interval> seconds. If set to B<false>
-only one such notification is generated until the value appears again.
-
-=item B<Percentage> B<true>|B<false>
-
-If set to B<true>, 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<nbsp>% of the total space is available. Defaults to B<false>.
-
-=item B<Hits> I<Value>
-
-Sets the number of occurrences which the threshold must be arised before to
-dispatch any notification or, in other words, the number of B<Interval>s
-than the threshold must be match before dispatch any notification.
-
-=item B<Hysteresis> I<Value>
-
-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<WarningMax>, B<FailureMin> or everthing else) minus the hysteresis value,
-the failure (respectively warning) state will be keep.
-
-=item B<Interesting> B<true>|B<false>
-
-If set to B<true> (the default), the threshold must be treated as
-interesting and, when a number of B<Timeout> values will lost, then
-a missing notification will be dispatched. On the other hand, if set to
-B<false>, the missing notification will never dispatched for this threshold.
-
-=back
-
=head1 FILTER CONFIGURATION
Starting with collectd 4.6 there is a powerful filtering infrastructure
#include "plugin.h"
#include "configfile.h"
#include "types_list.h"
-#include "utils_threshold.h"
#include "filter_chain.h"
#if HAVE_WORDEXP_H
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));
#include "utils_llist.h"
#include "utils_heap.h"
#include "utils_cache.h"
-#include "utils_threshold.h"
#include "filter_chain.h"
/*
/* 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);
--- /dev/null
+/**
+ * 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 <octo at collectd.org>
+ * Sebastian Harl <sh at tokkee.org>
+ * Andrés J. DÃaz <ajdiaz at connectical.com>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+#include "utils_avltree.h"
+#include "utils_cache.h"
+
+#include <assert.h>
+#include <pthread.h>
+
+/*
+ * 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 : */
#include "plugin.h"
#include "utils_avltree.h"
#include "utils_cache.h"
-#include "utils_threshold.h"
#include "meta_data.h"
#include <assert.h>
{
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;
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)
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 */
+++ /dev/null
-/**
- * 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 <octo at verplant.org>
- * Sebastian Harl <sh at tokkee.org>
- * Andrés J. DÃaz <ajdiaz at connectical.com>
- **/
-
-#include "collectd.h"
-#include "common.h"
-#include "plugin.h"
-#include "utils_avltree.h"
-#include "utils_cache.h"
-#include "utils_threshold.h"
-
-#include <assert.h>
-#include <pthread.h>
-
-/*
- * 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 : */
+++ /dev/null
-/**
- * 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 <octo at verplant.org>
- **/
-
-#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 */
projects / collectd.git / commitdiff