Code

Merge branch 'collectd-4.10' into collectd-5.0
[collectd.git] / src / collectd-nagios.c
1 /**
2  * collectd-nagios - src/collectd-nagios.c
3  * Copyright (C) 2008-2010  Florian octo Forster
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by the
7  * Free Software Foundation; only version 2 of the License is applicable.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
17  *
18  * Authors:
19  *   Florian octo Forster <octo at verplant.org>
20  **/
22 #if HAVE_CONFIG_H
23 # include "config.h"
24 #endif
26 #if !defined(__GNUC__) || !__GNUC__
27 # define __attribute__(x) /**/
28 #endif
30 #include <stdlib.h>
31 #include <unistd.h>
32 #include <stdio.h>
33 #include <errno.h>
34 #include <string.h>
35 #include <strings.h>
36 #include <assert.h>
38 #if NAN_STATIC_DEFAULT
39 # include <math.h>
40 /* #endif NAN_STATIC_DEFAULT*/
41 #elif NAN_STATIC_ISOC
42 # ifndef __USE_ISOC99
43 #  define DISABLE_ISOC99 1
44 #  define __USE_ISOC99 1
45 # endif /* !defined(__USE_ISOC99) */
46 # include <math.h>
47 # if DISABLE_ISOC99
48 #  undef DISABLE_ISOC99
49 #  undef __USE_ISOC99
50 # endif /* DISABLE_ISOC99 */
51 /* #endif NAN_STATIC_ISOC */
52 #elif NAN_ZERO_ZERO
53 # include <math.h>
54 # ifdef NAN
55 #  undef NAN
56 # endif
57 # define NAN (0.0 / 0.0)
58 # ifndef isnan
59 #  define isnan(f) ((f) != (f))
60 # endif /* !defined(isnan) */
61 # ifndef isfinite
62 #  define isfinite(f) (((f) - (f)) == 0.0)
63 # endif
64 # ifndef isinf
65 #  define isinf(f) (!isfinite(f) && !isnan(f))
66 # endif
67 #endif /* NAN_ZERO_ZERO */
69 #include "libcollectdclient/client.h"
71 #define RET_OKAY     0
72 #define RET_WARNING  1
73 #define RET_CRITICAL 2
74 #define RET_UNKNOWN  3
76 #define CON_NONE     0
77 #define CON_AVERAGE  1
78 #define CON_SUM      2
79 #define CON_PERCENTAGE  3
81 struct range_s
82 {
83         double min;
84         double max;
85         int    invert;
86 };
87 typedef struct range_s range_t;
89 extern char *optarg;
90 extern int optind, opterr, optopt;
92 static char *socket_file_g = NULL;
93 static char *value_string_g = NULL;
94 static char *hostname_g = NULL;
96 static range_t range_critical_g;
97 static range_t range_warning_g;
98 static int consolitation_g = CON_NONE;
99 static _Bool nan_is_error_g = 0;
101 static char **match_ds_g = NULL;
102 static int    match_ds_num_g = 0;
104 /* `strdup' is an XSI extension. I don't want to pull in all of XSI just for
105  * that, so here's an own implementation.. It's easy enough. The GCC attributes
106  * are supposed to get good performance..  -octo */
107 __attribute__((malloc, nonnull (1)))
108 static char *cn_strdup (const char *str) /* {{{ */
110   size_t strsize;
111   char *ret;
113   strsize = strlen (str) + 1;
114   ret = (char *) malloc (strsize);
115   if (ret != NULL)
116     memcpy (ret, str, strsize);
117   return (ret);
118 } /* }}} char *cn_strdup */
120 static int filter_ds (size_t *values_num,
121                 double **values, char ***values_names)
123         gauge_t *new_values;
124         char   **new_names;
126         size_t i;
128         if (match_ds_g == NULL)
129                 return (RET_OKAY);
131         new_values = (gauge_t *)calloc (match_ds_num_g, sizeof (*new_values));
132         if (new_values == NULL)
133         {
134                 fprintf (stderr, "malloc failed: %s\n", strerror (errno));
135                 return (RET_UNKNOWN);
136         }
138         new_names = (char **)calloc (match_ds_num_g, sizeof (*new_names));
139         if (new_names == NULL)
140         {
141                 fprintf (stderr, "malloc failed: %s\n", strerror (errno));
142                 free (new_values);
143                 return (RET_UNKNOWN);
144         }
146         for (i = 0; i < (size_t) match_ds_num_g; i++)
147         {
148                 size_t j;
150                 /* match_ds_g keeps pointers into argv but the names will be freed */
151                 new_names[i] = cn_strdup (match_ds_g[i]);
152                 if (new_names[i] == NULL)
153                 {
154                         fprintf (stderr, "cn_strdup failed: %s\n", strerror (errno));
155                         free (new_values);
156                         for (j = 0; j < i; j++)
157                                 free (new_names[j]);
158                         free (new_names);
159                         return (RET_UNKNOWN);
160                 }
162                 for (j = 0; j < *values_num; j++)
163                         if (strcasecmp (new_names[i], (*values_names)[j]) == 0)
164                                 break;
166                 if (j == *values_num)
167                 {
168                         printf ("ERROR: DS `%s' is not available.\n", new_names[i]);
169                         free (new_values);
170                         for (j = 0; j <= i; j++)
171                                 free (new_names[j]);
172                         free (new_names);
173                         return (RET_CRITICAL);
174                 }
176                 new_values[i] = (*values)[j];
177         }
179         free (*values);
180         for (i = 0; i < *values_num; i++)
181                 free ((*values_names)[i]);
182         free (*values_names);
184         *values       = new_values;
185         *values_names = new_names;
186         *values_num   = match_ds_num_g;
187         return (RET_OKAY);
188 } /* int filter_ds */
190 static void parse_range (char *string, range_t *range)
192         char *min_ptr;
193         char *max_ptr;
195         if (*string == '@')
196         {
197                 range->invert = 1;
198                 string++;
199         }
201         max_ptr = strchr (string, ':');
202         if (max_ptr == NULL)
203         {
204                 min_ptr = NULL;
205                 max_ptr = string;
206         }
207         else
208         {
209                 min_ptr = string;
210                 *max_ptr = '\0';
211                 max_ptr++;
212         }
214         assert (max_ptr != NULL);
216         /* `10' == `0:10' */
217         if (min_ptr == NULL)
218                 range->min = 0.0;
219         /* :10 == ~:10 == -inf:10 */
220         else if ((*min_ptr == '\0') || (*min_ptr == '~'))
221                 range->min = NAN;
222         else
223                 range->min = atof (min_ptr);
225         if ((*max_ptr == '\0') || (*max_ptr == '~'))
226                 range->max = NAN;
227         else
228                 range->max = atof (max_ptr);
229 } /* void parse_range */
231 static int match_range (range_t *range, double value)
233         int ret = 0;
235         if (!isnan (range->min) && (range->min > value))
236                 ret = 1;
237         if (!isnan (range->max) && (range->max < value))
238                 ret = 1;
240         return (((ret - range->invert) == 0) ? 0 : 1);
241 } /* int match_range */
243 static void usage (const char *name)
245         fprintf (stderr, "Usage: %s <-s socket> <-n value_spec> <-H hostname> [options]\n"
246                         "\n"
247                         "Valid options are:\n"
248                         "  -s <socket>    Path to collectd's UNIX-socket.\n"
249                         "  -n <v_spec>    Value specification to get from collectd.\n"
250                         "                 Format: `plugin-instance/type-instance'\n"
251                         "  -d <ds>        Select the DS to examine. May be repeated to examine multiple\n"
252                         "                 DSes. By default all DSes are used.\n"
253                         "  -g <consol>    Method to use to consolidate several DSes.\n"
254                         "                 See below for a list of valid arguments.\n"
255                         "  -H <host>      Hostname to query the values for.\n"
256                         "  -c <range>     Critical range\n"
257                         "  -w <range>     Warning range\n"
258                         "  -m             Treat \"Not a Number\" (NaN) as critical (default: warning)\n"
259                         "\n"
260                         "Consolidation functions:\n"
261                         "  none:          Apply the warning- and critical-ranges to each data-source\n"
262                         "                 individually.\n"
263                         "  average:       Calculate the average of all matching DSes and apply the\n"
264                         "                 warning- and critical-ranges to the calculated average.\n"
265                         "  sum:           Apply the ranges to the sum of all DSes.\n"
266                         "  percentage:    Apply the ranges to the ratio (in percent) of the first value\n"
267                         "                 and the sum of all values."
268                         "\n", name);
269         exit (1);
270 } /* void usage */
272 static int do_check_con_none (size_t values_num,
273                 double *values, char **values_names)
275         int num_critical = 0;
276         int num_warning  = 0;
277         int num_okay = 0;
278         const char *status_str = "UNKNOWN";
279         int status_code = RET_UNKNOWN;
280         size_t i;
282         for (i = 0; i < values_num; i++)
283         {
284                 if (isnan (values[i]))
285                 {
286                         if (nan_is_error_g)
287                                 num_critical++;
288                         else
289                                 num_warning++;
290                 }
291                 else if (match_range (&range_critical_g, values[i]) != 0)
292                         num_critical++;
293                 else if (match_range (&range_warning_g, values[i]) != 0)
294                         num_warning++;
295                 else
296                         num_okay++;
297         }
299         if ((num_critical == 0) && (num_warning == 0) && (num_okay == 0))
300         {
301                 printf ("WARNING: No defined values found\n");
302                 return (RET_WARNING);
303         }
304         else if ((num_critical == 0) && (num_warning == 0))
305         {
306                 status_str = "OKAY";
307                 status_code = RET_OKAY;
308         }
309         else if (num_critical == 0)
310         {
311                 status_str = "WARNING";
312                 status_code = RET_WARNING;
313         }
314         else
315         {
316                 status_str = "CRITICAL";
317                 status_code = RET_CRITICAL;
318         }
320         printf ("%s: %i critical, %i warning, %i okay", status_str,
321                         num_critical, num_warning, num_okay);
322         if (values_num > 0)
323         {
324                 printf (" |");
325                 for (i = 0; i < values_num; i++)
326                         printf (" %s=%f;;;;", values_names[i], values[i]);
327         }
328         printf ("\n");
330         return (status_code);
331 } /* int do_check_con_none */
333 static int do_check_con_average (size_t values_num,
334                 double *values, char **values_names)
336         size_t i;
337         double total;
338         int total_num;
339         double average;
340         const char *status_str = "UNKNOWN";
341         int status_code = RET_UNKNOWN;
343         total = 0.0;
344         total_num = 0;
345         for (i = 0; i < values_num; i++)
346         {
347                 if (isnan (values[i]))
348                 {
349                         if (!nan_is_error_g)
350                                 continue;
352                         printf ("CRITICAL: Data source \"%s\" is NaN\n",
353                                         values_names[i]);
354                         return (RET_CRITICAL);
355                 }
357                 total += values[i];
358                 total_num++;
359         }
361         if (total_num == 0)
362         {
363                 printf ("WARNING: No defined values found\n");
364                 return (RET_WARNING);
365         }
367         average = total / total_num;
369         if (match_range (&range_critical_g, average) != 0)
370         {
371                 status_str = "CRITICAL";
372                 status_code = RET_CRITICAL;
373         }
374         else if (match_range (&range_warning_g, average) != 0)
375         {
376                 status_str = "WARNING";
377                 status_code = RET_WARNING;
378         }
379         else
380         {
381                 status_str = "OKAY";
382                 status_code = RET_OKAY;
383         }
385         printf ("%s: %g average |", status_str, average);
386         for (i = 0; i < values_num; i++)
387                 printf (" %s=%f;;;;", values_names[i], values[i]);
388         printf ("\n");
390         return (status_code);
391 } /* int do_check_con_average */
393 static int do_check_con_sum (size_t values_num,
394                 double *values, char **values_names)
396         size_t i;
397         double total;
398         int total_num;
399         const char *status_str = "UNKNOWN";
400         int status_code = RET_UNKNOWN;
402         total = 0.0;
403         total_num = 0;
404         for (i = 0; i < values_num; i++)
405         {
406                 if (isnan (values[i]))
407                 {
408                         if (!nan_is_error_g)
409                                 continue;
411                         printf ("CRITICAL: Data source \"%s\" is NaN\n",
412                                         values_names[i]);
413                         return (RET_CRITICAL);
414                 }
416                 total += values[i];
417                 total_num++;
418         }
420         if (total_num == 0)
421         {
422                 printf ("WARNING: No defined values found\n");
423                 return (RET_WARNING);
424         }
426         if (match_range (&range_critical_g, total) != 0)
427         {
428                 status_str = "CRITICAL";
429                 status_code = RET_CRITICAL;
430         }
431         else if (match_range (&range_warning_g, total) != 0)
432         {
433                 status_str = "WARNING";
434                 status_code = RET_WARNING;
435         }
436         else
437         {
438                 status_str = "OKAY";
439                 status_code = RET_OKAY;
440         }
442         printf ("%s: %g sum |", status_str, total);
443         for (i = 0; i < values_num; i++)
444                 printf (" %s=%f;;;;", values_names[i], values[i]);
445         printf ("\n");
447         return (status_code);
448 } /* int do_check_con_sum */
450 static int do_check_con_percentage (size_t values_num,
451                 double *values, char **values_names)
453         size_t i;
454         double sum = 0.0;
455         double percentage;
457         const char *status_str  = "UNKNOWN";
458         int         status_code = RET_UNKNOWN;
460         if ((values_num < 1) || (isnan (values[0])))
461         {
462                 printf ("WARNING: The first value is not defined\n");
463                 return (RET_WARNING);
464         }
466         for (i = 0; i < values_num; i++)
467         {
468                 if (isnan (values[i]))
469                 {
470                         if (!nan_is_error_g)
471                                 continue;
473                         printf ("CRITICAL: Data source \"%s\" is NaN\n",
474                                         values_names[i]);
475                         return (RET_CRITICAL);
476                 }
478                 sum += values[i];
479         }
481         if (sum == 0.0)
482         {
483                 printf ("WARNING: Values sum up to zero\n");
484                 return (RET_WARNING);
485         }
487         percentage = 100.0 * values[0] / sum;
489         if (match_range (&range_critical_g, percentage) != 0)
490         {
491                 status_str  = "CRITICAL";
492                 status_code = RET_CRITICAL;
493         }
494         else if (match_range (&range_warning_g, percentage) != 0)
495         {
496                 status_str  = "WARNING";
497                 status_code = RET_WARNING;
498         }
499         else
500         {
501                 status_str  = "OKAY";
502                 status_code = RET_OKAY;
503         }
505         printf ("%s: %lf percent |", status_str, percentage);
506         for (i = 0; i < values_num; i++)
507                 printf (" %s=%lf;;;;", values_names[i], values[i]);
508         return (status_code);
509 } /* int do_check_con_percentage */
511 static int do_check (void)
513         lcc_connection_t *connection;
514         gauge_t *values;
515         char   **values_names;
516         size_t   values_num;
517         char address[1024];
518         char ident_str[1024];
519         lcc_identifier_t ident;
520         size_t i;
521         int status;
523         snprintf (address, sizeof (address), "unix:%s", socket_file_g);
524         address[sizeof (address) - 1] = 0;
526         snprintf (ident_str, sizeof (ident_str), "%s/%s",
527                         hostname_g, value_string_g);
528         ident_str[sizeof (ident_str) - 1] = 0;
530         connection = NULL;
531         status = lcc_connect (address, &connection);
532         if (status != 0)
533         {
534                 printf ("ERROR: Connecting to daemon at %s failed.\n",
535                                 socket_file_g);
536                 return (RET_CRITICAL);
537         }
539         memset (&ident, 0, sizeof (ident));
540         status = lcc_string_to_identifier (connection, &ident, ident_str);
541         if (status != 0)
542         {
543                 printf ("ERROR: Creating an identifier failed: %s.\n",
544                                 lcc_strerror (connection));
545                 LCC_DESTROY (connection);
546                 return (RET_CRITICAL);
547         }
549         status = lcc_getval (connection, &ident,
550                         &values_num, &values, &values_names);
551         if (status != 0)
552         {
553                 printf ("ERROR: Retrieving values from the daemon failed: %s.\n",
554                                 lcc_strerror (connection));
555                 LCC_DESTROY (connection);
556                 return (RET_CRITICAL);
557         }
559         LCC_DESTROY (connection);
561         status = filter_ds (&values_num, &values, &values_names);
562         if (status != RET_OKAY)
563                 return (status);
565         status = RET_UNKNOWN;
566         if (consolitation_g == CON_NONE)
567                 status =  do_check_con_none (values_num, values, values_names);
568         else if (consolitation_g == CON_AVERAGE)
569                 status =  do_check_con_average (values_num, values, values_names);
570         else if (consolitation_g == CON_SUM)
571                 status = do_check_con_sum (values_num, values, values_names);
572         else if (consolitation_g == CON_PERCENTAGE)
573                 status = do_check_con_percentage (values_num, values, values_names);
575         free (values);
576         if (values_names != NULL)
577                 for (i = 0; i < values_num; i++)
578                         free (values_names[i]);
579         free (values_names);
581         return (status);
582 } /* int do_check */
584 int main (int argc, char **argv)
586         range_critical_g.min = NAN;
587         range_critical_g.max = NAN;
588         range_critical_g.invert = 0;
590         range_warning_g.min = NAN;
591         range_warning_g.max = NAN;
592         range_warning_g.invert = 0;
594         while (42)
595         {
596                 int c;
598                 c = getopt (argc, argv, "w:c:s:n:H:g:d:hm");
599                 if (c < 0)
600                         break;
602                 switch (c)
603                 {
604                         case 'c':
605                                 parse_range (optarg, &range_critical_g);
606                                 break;
607                         case 'w':
608                                 parse_range (optarg, &range_warning_g);
609                                 break;
610                         case 's':
611                                 socket_file_g = optarg;
612                                 break;
613                         case 'n':
614                                 value_string_g = optarg;
615                                 break;
616                         case 'H':
617                                 hostname_g = optarg;
618                                 break;
619                         case 'g':
620                                 if (strcasecmp (optarg, "none") == 0)
621                                         consolitation_g = CON_NONE;
622                                 else if (strcasecmp (optarg, "average") == 0)
623                                         consolitation_g = CON_AVERAGE;
624                                 else if (strcasecmp (optarg, "sum") == 0)
625                                         consolitation_g = CON_SUM;
626                                 else if (strcasecmp (optarg, "percentage") == 0)
627                                         consolitation_g = CON_PERCENTAGE;
628                                 else
629                                 {
630                                         fprintf (stderr, "Unknown consolidation function `%s'.\n",
631                                                         optarg);
632                                         usage (argv[0]);
633                                 }
634                                 break;
635                         case 'd':
636                         {
637                                 char **tmp;
638                                 tmp = (char **) realloc (match_ds_g,
639                                                 (match_ds_num_g + 1)
640                                                 * sizeof (char *));
641                                 if (tmp == NULL)
642                                 {
643                                         fprintf (stderr, "realloc failed: %s\n",
644                                                         strerror (errno));
645                                         return (RET_UNKNOWN);
646                                 }
647                                 match_ds_g = tmp;
648                                 match_ds_g[match_ds_num_g] = cn_strdup (optarg);
649                                 if (match_ds_g[match_ds_num_g] == NULL)
650                                 {
651                                         fprintf (stderr, "cn_strdup failed: %s\n",
652                                                         strerror (errno));
653                                         return (RET_UNKNOWN);
654                                 }
655                                 match_ds_num_g++;
656                                 break;
657                         }
658                         case 'm':
659                                 nan_is_error_g = 1;
660                                 break;
661                         default:
662                                 usage (argv[0]);
663                 } /* switch (c) */
664         }
666         if ((socket_file_g == NULL) || (value_string_g == NULL)
667                         || (hostname_g == NULL))
668         {
669                 fprintf (stderr, "Missing required arguments.\n");
670                 usage (argv[0]);
671         }
673         return (do_check ());
674 } /* int main */