contrib/exec-nagios.px

   1 #!/usr/bin/perl
   2
   3 use strict;
   4 use warnings;
   5
   6 =head1 NAME
   7
   8 exec-nagios.px
   9
  10 =head1 DESCRIPTION
  11
  12 This script allows you to use plugins that were written for Nagios with
  13 collectd's C<exec-plugin>. If the plugin checks some kind of threshold, please
  14 consider configuring the threshold using collectd's own facilities instead of
  15 using this transition layer.
  16
  17 =cut
  18
  19 use Sys::Hostname ('hostname');
  20 use File::Basename ('basename');
  21 use Config::General ('ParseConfig');
  22 use Regexp::Common ('number');
  23
  24 our $ConfigFile = '/etc/exec-nagios.conf';
  25 our $TypeMap = {};
  26 our $Scripts = [];
  27 our $Interval = 300;
  28
  29 main ();
  30 exit (0);
  31
  32 # Configuration
  33 # {{{
  34
  35 =head1 CONFIGURATION
  36
  37 This script reads it's configuration from F</etc/exec-nagios.conf>. The
  38 configuration is read using C<Config::General> which understands a Apache-like
  39 config syntax, so it's very similar to the F<collectd.conf> syntax, too.
  40
  41 Here's a short sample config:
  42
  43   Interval 300
  44   <Script /usr/lib/nagios/check_tcp>
  45     Arguments -H alice -p 22
  46     Type delay
  47   </Script>
  48   <Script /usr/lib/nagios/check_dns>
  49     Arguments -H alice
  50     Type delay
  51   </Script>
  52
  53 The options have the following semantic (i.E<nbsp>e. meaning):
  54
  55 =over 4
  56
  57 =item B<Interval> I<Seconds>
  58
  59 Sets the interval in which the plugins are executed. This doesn't need to match
  60 the interval setting of the collectd daemon. Usually, you want to execute the
  61 Nagios plugins much less often, e.E<nbsp>g. every 300 seconds versus every 10
  62 seconds.
  63
  64 =item E<lt>B<Script> I<File>E<gt>
  65
  66 Adds a script to the list of scripts to be executed once per I<Interval>
  67 seconds. You can use the following optional arguments to specify the operation
  68 further:
  69
  70 =over 4
  71
  72 =item B<Arguments> I<Arguments>
  73
  74 Pass the arguments I<Arguments> to the script. This is often needed with Nagios
  75 plugins, because much of the logic is implemented in the plugins, not in the
  76 daemon. If you need to specify a warning and/or critical range here, please
  77 consider using collectd's own threshold mechanism, which is by far the more
  78 elegant solution than this transition layer.
  79
  80 =item B<Type> I<Type>
  81
  82 If the plugin provides "performance data" the performance data is dispatched to
  83 collectd with this type. If no type is configured the data is ignored. Please
  84 note that this is limited to types that take exactly one value, such as the
  85 type C<delay> in the example above. If you need more complex performance data,
  86 rewrite the plugin as a collectd plugin (or at least port it do run directly
  87 with the C<exec-plugin>).
  88
  89 =back
  90
  91 =back
  92
  93 =cut
  94
  95 sub handle_config_addtype
  96 {
  97   my $list = shift;
  98
  99   for (my $i = 0; $i < @$list; $i++)
 100   {
 101     my ($to, @from) = split (' ', $list->[$i]);
 102     for (my $j = 0; $j < @from; $j++)
 103     {
 104       $TypeMap->{$from[$j]} = $to;
 105     }
 106   }
 107 } # handle_config_addtype
 108
 109 sub handle_config_script
 110 {
 111   my $scripts = shift;
 112
 113   for (keys %$scripts)
 114   {
 115     my $script = $_;
 116     my $opts = $scripts->{$script};
 117
 118     if (!-e $script)
 119     {
 120       print STDERR "Script `$script' doesn't exist.\n";
 121     }
 122     elsif (!-x $script)
 123     {
 124       print STDERR "Script `$script' exists but is not executable.\n";
 125     }
 126     else
 127     {
 128       if (ref ($opts) eq 'ARRAY')
 129         {
 130           for (@$opts)
 131             {
 132               my $opt = $_;
 133               $opt->{'script'} = $script;
 134               push (@$Scripts, $opt);
 135             }
 136         }
 137           else
 138         {
 139           $opts->{'script'} = $script;
 140           push (@$Scripts, $opts);
 141         }
 142     }
 143   } # for (keys %$scripts)
 144 } # handle_config_script
 145
 146 sub handle_config
 147 {
 148   my $config = shift;
 149
 150   if (defined ($config->{'addtype'}))
 151   {
 152     if (ref ($config->{'addtype'}) eq 'ARRAY')
 153     {
 154       handle_config_addtype ($config->{'addtype'});
 155     }
 156     elsif (ref ($config->{'addtype'}) eq '')
 157     {
 158       handle_config_addtype ([$config->{'addtype'}]);
 159     }
 160     else
 161     {
 162       print STDERR "Cannot handle ref type '"
 163       . ref ($config->{'addtype'}) . "' for option 'AddType'.\n";
 164     }
 165   }
 166
 167   if (defined ($config->{'script'}))
 168   {
 169     if (ref ($config->{'script'}) eq 'HASH')
 170     {
 171       handle_config_script ($config->{'script'});
 172     }
 173     else
 174     {
 175       print STDERR "Cannot handle ref type '"
 176       . ref ($config->{'script'}) . "' for option 'Script'.\n";
 177     }
 178   }
 179
 180   if (defined ($config->{'interval'})
 181     && (ref ($config->{'interval'}) eq ''))
 182   {
 183     my $num = int ($config->{'interval'});
 184     if ($num > 0)
 185     {
 186       $Interval = $num;
 187     }
 188   }
 189 } # handle_config }}}
 190
 191 sub scale_value
 192 {
 193   my $value = shift;
 194   my $unit = shift;
 195
 196   if (!$unit)
 197   {
 198     return ($value);
 199   }
 200
 201   if (($unit =~ m/^mb(yte)?$/i) || ($unit eq 'M'))
 202   {
 203     return ($value * 1000000);
 204   }
 205   elsif ($unit =~ m/^k(b(yte)?)?$/i)
 206   {
 207     return ($value * 1000);
 208   }
 209
 210   return ($value);
 211 }
 212
 213 sub sanitize_instance
 214 {
 215   my $inst = shift;
 216
 217   if ($inst eq '/')
 218   {
 219     return ('root');
 220   }
 221
 222   $inst =~ s/[^A-Za-z_-]/_/g;
 223   $inst =~ s/__+/_/g;
 224   $inst =~ s/^_//;
 225   $inst =~ s/_$//;
 226
 227   return ($inst);
 228 }
 229
 230 sub handle_performance_data
 231 {
 232   my $host = shift;
 233   my $plugin = shift;
 234   my $pinst = shift;
 235   my $type = shift;
 236   my $time = shift;
 237   my $line = shift;
 238
 239   my $tinst;
 240   my $value;
 241   my $unit;
 242
 243   if ($line =~ m/^([^=]+)=($RE{num}{real})([^;]*)/)
 244   {
 245     $tinst = sanitize_instance ($1);
 246     $value = scale_value ($2, $3);
 247   }
 248   else
 249   {
 250     return;
 251   }
 252
 253   print "PUTVAL $host/$plugin-$pinst/$type-$tinst interval=$Interval ${time}:$value\n";
 254 }
 255
 256 sub execute_script
 257 {
 258   my $fh;
 259   my $pinst;
 260   my $time = time ();
 261   my $script = shift;
 262   my @args = ();
 263   my $host = hostname () || 'localhost';
 264
 265   my $state = 0;
 266   my $serviceoutput;
 267   my @serviceperfdata;
 268   my @longserviceoutput;
 269
 270   my $script_name = $script->{'script'};
 271
 272   if ($script->{'arguments'})
 273   {
 274     @args = split (' ', $script->{'arguments'});
 275   }
 276
 277   if (!open ($fh, '-|', $script_name, @args))
 278   {
 279     print STDERR "Cannot execute $script_name: $!";
 280     return;
 281   }
 282
 283   $pinst = sanitize_instance (basename ($script_name));
 284
 285   # Parse the output of the plugin. The format is seriously fucked up, because
 286   # it got extended way beyond what it could handle.
 287   while (my $line = <$fh>)
 288   {
 289     chomp ($line);
 290
 291     if ($state == 0)
 292     {
 293       my $perfdata;
 294       ($serviceoutput, $perfdata) = split (m/\s*\|\s*/, $line, 2);
 295
 296       if ($perfdata)
 297       {
 298         push (@serviceperfdata, split (' ', $perfdata));
 299       }
 300
 301       $state = 1;
 302     }
 303     elsif ($state == 1)
 304     {
 305       my $longoutput;
 306       my $perfdata;
 307       ($longoutput, $perfdata) = split (m/\s*\|\s*/, $line, 2);
 308
 309       push (@longserviceoutput, $longoutput);
 310
 311       if ($perfdata)
 312       {
 313         push (@serviceperfdata, split (' ', $perfdata));
 314         $state = 2;
 315       }
 316     }
 317     else # ($state == 2)
 318     {
 319       push (@serviceperfdata, split (' ', $line));
 320     }
 321   }
 322
 323   close ($fh);
 324   # Save the exit status of the check in $state
 325   $state = $?;
 326
 327   if ($state == 0)
 328   {
 329     $state = 'okay';
 330   }
 331   elsif ($state == 1)
 332   {
 333     $state = 'warning';
 334   }
 335   else
 336   {
 337     $state = 'failure';
 338   }
 339
 340   {
 341     my $type = $script->{'type'} || 'nagios_check';
 342
 343     print "PUTNOTIF time=$time severity=$state host=$host plugin=nagios "
 344     . "plugin_instance=$pinst type=$type message=$serviceoutput\n";
 345   }
 346
 347   if ($script->{'type'})
 348   {
 349     for (@serviceperfdata)
 350     {
 351       handle_performance_data ($host, 'nagios', $pinst, $script->{'type'},
 352         $time, $_);
 353     }
 354   }
 355 } # execute_script
 356
 357 sub main
 358 {
 359   my $last_run;
 360   my $next_run;
 361
 362   my %config = ParseConfig (-ConfigFile => $ConfigFile,
 363     -AutoTrue => 1,
 364     -LowerCaseNames => 1);
 365   handle_config (\%config);
 366
 367   while (42)
 368   {
 369     $last_run = time ();
 370     $next_run = $last_run + $Interval;
 371
 372     for (@$Scripts)
 373     {
 374       execute_script ($_);
 375     }
 376
 377     while ((my $timeleft = ($next_run - time ())) > 0)
 378     {
 379       sleep ($timeleft);
 380     }
 381   }
 382 } # main
 383
 384 =head1 REQUIREMENTS
 385
 386 This script requires the following Perl modules to be installed:
 387
 388 =over 4
 389
 390 =item C<Config::General>
 391
 392 =item C<Regexp::Common>
 393
 394 =back
 395
 396 =head1 SEE ALSO
 397
 398 L<http://www.nagios.org/>,
 399 L<http://nagiosplugins.org/>,
 400 L<http://collectd.org/>,
 401 L<collectd-exec(5)>
 402
 403 =head1 AUTHOR
 404
 405 Florian octo Forster E<lt>octo at verplant.orgE<gt>
 406
 407 =cut
 408
 409 # vim: set sw=2 sts=2 ts=8 fdm=marker :