#!/usr/bin/perl -w # Check CPU Usage via SNMP ( with performance reporting ). # The following values are reported for performance data: # User, System, Idle, Wait # # Plugin uses UCD SNMP MIB (1.3.6.1.4.1.2021.11 systemStats). # Used in net-snmp packages on linux. # # Copyright (C) 2009 by Herbert Stadler # email: hestadler@gmx.at # License Information: # 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; either version 3 of the License, or # (at your option) any later version. # # 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, see . # # ############################################################################ use POSIX; use strict; # if "use warnings" is activated ePN will fail compiling # use warnings; use Getopt::Long; use lib "."; use lib "/usr/lib/nagios/plugins"; use lib "/usr/lib64/nagios/plugins"; use lib "/usr/local/nagios/libexec"; use utils qw(%ERRORS); use Net::SNMP qw(oid_lex_sort oid_base_match :debug); use constant TRANSLATE_OIDs => 0; my ($opt_version,$opt_help,$opt_verbose); my ($opt_timeout,$opt_license); my ($opt_hostname,$opt_community,$opt_port,$opt_snmpvers); my ($opt_username,$opt_authpasswd,$opt_authproto); my ($opt_privpasswd,$opt_privproto); my ($opt_snmpdebug,$opt_snmptimeout,$opt_warn,$opt_crit); my ($PROGNAME,$REVISION); my ($state,$msg); my ($g_snmpdebug); use constant DEFAULT_TIMEOUT =>15; use constant DEFAULT_PORT =>161; use constant DEFAULT_COMMUNITY =>"public"; use constant DEFAULT_SNMPVERS =>"2"; use constant DEFAULT_PRIVPROTO =>"DES"; use constant DEFAULT_AUTHPROTO =>"MD5"; use constant WAIT_BETWEEN_MEASUREMENT =>5; # UCD SNMP MIB my $systemStats ="1.3.6.1.4.1.2021.11"; my $ssCpuRawUser =$systemStats . ".50"; my $ssCpuRawNice =$systemStats . ".51"; my $ssCpuRawSystem =$systemStats . ".52"; my $ssCpuRawIdle =$systemStats . ".53"; my $ssCpuRawWait =$systemStats . ".54"; my $ssCpuRawKernel =$systemStats . ".55"; my $ssCpuRawInterrupt =$systemStats . ".56"; my $ssCpuRawSoftIRQ =$systemStats . ".61"; my $kssCpuRawUser =$ssCpuRawUser . ".0"; my $kssCpuRawNice =$ssCpuRawNice . ".0"; my $kssCpuRawSystem =$ssCpuRawSystem . ".0"; my $kssCpuRawIdle =$ssCpuRawIdle . ".0"; my $kssCpuRawWait =$ssCpuRawWait . ".0"; my $kssCpuRawKernel =$ssCpuRawKernel . ".0"; my $kssCpuRawInterrupt =$ssCpuRawInterrupt . ".0"; my $kssCpuRawSoftIRQ =$ssCpuRawSoftIRQ . ".0"; my $DEFAULT_SNMPTIMEOUT = 2; my $ticks_per_second = 100; $ENV{'PATH'}=''; $ENV{'BASH_ENV'}=''; $ENV{'ENV'}=''; $PROGNAME = "check_cpu_ucd"; $REVISION = "1.2"; # checking commandline arguments my $arg_status = check_args(); if ($arg_status){ print "ERROR: some arguments wrong\n"; exit $ERRORS{"UNKNOWN"}; } if ($opt_snmpdebug) { my $module="Net::SNMP"; printf( "%-20s Version: %s\n", $module, $module->VERSION ); } # set alarmhandler for timeout handling $SIG{'ALRM'} = sub { print ("ERROR: plugin timed out after $opt_timeout seconds \n"); exit $ERRORS{"UNKNOWN"}; }; alarm($opt_timeout); # get some OID's my $a_oids=(); push (@{$a_oids},$ssCpuRawUser); push (@{$a_oids},$ssCpuRawNice); push (@{$a_oids},$ssCpuRawSystem); push (@{$a_oids},$ssCpuRawIdle); push (@{$a_oids},$ssCpuRawWait); push (@{$a_oids},$ssCpuRawKernel); push (@{$a_oids},$ssCpuRawInterrupt); push (@{$a_oids},$ssCpuRawSoftIRQ); if ( $opt_verbose ) { printf("Starting SNMP Session\n"); } # let's see if the server wants to speak with us my ($snmp_session,$snmp_error)=open_snmp_session($opt_hostname); if ( ! defined ($snmp_session)) { print "ERROR: Could not open connection: $snmp_error \n"; exit $ERRORS{'UNKNOWN'}; } $snmp_session->translate(['-endofmibview'=>0,'-nosuchobject'=>0,'-nosuchinstance'=>0]); if ( $opt_verbose ) { printf("1st Measurement of CPU-Load\n"); } # get the OID's 1st measurement my $hValOid1st=get_request($a_oids); if ( $opt_verbose ) { printf("Waiting %d seconds\n",WAIT_BETWEEN_MEASUREMENT); } # now we are waiting some seconds sleep (WAIT_BETWEEN_MEASUREMENT); if ( $opt_verbose ) { printf("2nd Measurement of CPU-Load\n"); } # get the OID's 2nd measurement my $hValOid2nd=get_request($a_oids); $snmp_session->close; if ( $opt_verbose ) { print_Single_OIDs($hValOid1st); print_Single_OIDs($hValOid2nd); } # These values can be found under linux in /proc/stat: # > cat /proc/stat # cpu 2255 34 2290 22625563 6290 127 456 # The very first "cpu" line aggregates the numbers in all of the # other "cpuN" lines. # These numbers identify the amount of time the CPU has spent performing # different kinds of work. Time units are in USER_HZ or Jiffies # (typically hundredths of a second). # The meanings of the columns are as follows, from left to right: # user: normal processes executing in user mode # nice: niced processes executing in user mode # system: processes executing in kernel mode # idle: twiddling thumbs # iowait: waiting for I/O to complete # irq: servicing interrupts # softirq: servicing softirqs # # Explanation of system: # system = ssCpuRawKernel + ssCpuRawInterrupt + ssCpuRawSoftIRQ # # Documentation under: http://www.linuxhowtos.org/System/procstat.htm my $g_not_numeric_found=0; my $g_value_not_found=0; # sum up the OID's my $hcalc={}; Make_Sums($hcalc,"1st",$hValOid1st); Make_Sums($hcalc,"2nd",$hValOid2nd); if ( $g_not_numeric_found == 1 ) { printf("ERROR: some/all values not numeric\n"); exit $ERRORS{'UNKNOWN'}; } if ( $g_value_not_found == 1 ) { printf("ERROR: no/not all CPU values received\n"); exit $ERRORS{'UNKNOWN'}; } # now we build the difference between the 2 measuring points $hcalc->{"us_diff"} =$hcalc->{"us_2nd"} - $hcalc->{"us_1st"}; $hcalc->{"sy_diff"} =$hcalc->{"sy_2nd"} - $hcalc->{"sy_1st"}; $hcalc->{"id_diff"} =$hcalc->{"id_2nd"} - $hcalc->{"id_1st"}; $hcalc->{"wa_diff"} =$hcalc->{"wa_2nd"} - $hcalc->{"wa_1st"}; $hcalc->{"total_diff"}=$hcalc->{"total_2nd"} - $hcalc->{"total_1st"}; # Calculation of percentages my $us_pct=0; my $sy_pct=0; my $id_pct=0; my $wa_pct=0; if ( $opt_verbose ) { if ( $hcalc->{"total_diff"} == 0 ) { printf ("\nATTENTION: Total Value == 0\n"); } } if ( $hcalc->{"total_diff"} != 0 ) { $us_pct=Round_Number($hcalc->{"us_diff"} * 100 / $hcalc->{"total_diff"},0); $sy_pct=Round_Number($hcalc->{"sy_diff"} * 100 / $hcalc->{"total_diff"},0); $id_pct=Round_Number($hcalc->{"id_diff"} * 100 / $hcalc->{"total_diff"},0); $wa_pct=Round_Number($hcalc->{"wa_diff"} * 100 / $hcalc->{"total_diff"},0); } # checking a linux system will show us the same values as "vmstat" if ( $opt_verbose ) { printf ("\nDIFFERENCE VALUES in timeticks and percent:\n"); printf ("us: %16d, %4.2f%%\n",$hcalc->{"us_diff"},$us_pct); printf ("sy: %16d, %4.2f%%\n",$hcalc->{"sy_diff"},$sy_pct); printf ("id: %16d, %4.2f%%\n",$hcalc->{"id_diff"},$id_pct); printf ("wa: %16d, %4.2f%%\n",$hcalc->{"wa_diff"},$wa_pct); printf ("total: %16d\n",$hcalc->{"total_diff"}); } # wa_pct & id_pct produces no load on system, therefore we don't add this my $processor_load=$us_pct + $sy_pct; # Build performance data line my $perfdata=sprintf("us=%d%% sy=%d%% id=%d%% wa=%d%%",$us_pct,$sy_pct,$id_pct,$wa_pct); if ( $processor_load < $opt_warn ) { $msg = sprintf("CPU OK - No Problems found (%d%%)",$processor_load); $state = $ERRORS{'OK'}; }elsif ( $processor_load < $opt_crit ) { $msg = sprintf("CPU WARN - Usage %d%%",$processor_load); $state = $ERRORS{'WARNING'}; }else{ $msg = sprintf("CPU CRIT - Usage %d%%",$processor_load); $state = $ERRORS{'CRITICAL'}; } # attach performance data line $msg.="|".$perfdata; # and now "over and out" print "$msg\n"; exit $state; #--------------------------------------------------------------------------# # S U B R O U T I N E S # #--------------------------------------------------------------------------# #-------------------------------------------------------------------------- sub open_snmp_session { #-------------------------------------------------------------------------- my ($l_host)=@_; my ($snmp_session,$snmp_error); # open SNMP Session to Server if ( $opt_snmpvers eq "3" ) { if ( defined ($opt_authpasswd)) { if ( defined ($opt_privpasswd)) { ($snmp_session,$snmp_error)=Net::SNMP->session( -hostname => $l_host, -port => $opt_port, -timeout => $opt_snmptimeout, -retries => 2, -debug => $g_snmpdebug, -maxmsgsize => 16384, -version => $opt_snmpvers, -username => $opt_username, -authpassword => $opt_authpasswd, -authprotocol => $opt_authproto, -privpassword => $opt_privpasswd, -privprotocol => $opt_privproto, ); } else { ($snmp_session,$snmp_error)=Net::SNMP->session( -hostname => $l_host, -port => $opt_port, -timeout => $opt_snmptimeout, -retries => 2, -debug => $g_snmpdebug, -maxmsgsize => 16384, -version => $opt_snmpvers, -username => $opt_username, -authpassword => $opt_authpasswd, -authprotocol => $opt_authproto, ); } } else { ($snmp_session,$snmp_error)=Net::SNMP->session( -hostname => $l_host, -port => $opt_port, -timeout => $opt_snmptimeout, -retries => 2, -debug => $g_snmpdebug, -maxmsgsize => 16384, -version => $opt_snmpvers, -username => $opt_username, ); } } else { ($snmp_session,$snmp_error)=Net::SNMP->session( -hostname => $l_host, -community => $opt_community, -port => $opt_port, -timeout => $opt_snmptimeout, -retries => 2, -debug => $g_snmpdebug, -maxmsgsize => 16384, -version => $opt_snmpvers, ); } return ($snmp_session,$snmp_error); } #-------------------------------------------------------------------------- sub Add_Value { #-------------------------------------------------------------------------- my ($hcalc,$hValOid,$key,$kssCpu)=@_; if (defined($hValOid->{$kssCpu})) { if ($hValOid->{$kssCpu} =~ /^\d+$/ ) { $hcalc->{$key}+=$hValOid->{$kssCpu}; }else{ $g_not_numeric_found=1; } }else{ $g_value_not_found=1; } } #-------------------------------------------------------------------------- sub Make_Sums { #-------------------------------------------------------------------------- my ($hcalc,$key,$hValOid)=@_; my $uskey = "us_".$key; my $sykey = "sy_".$key; my $idkey = "id_".$key; my $wakey = "wa_".$key; my $totalkey = "total_".$key; $hcalc->{$uskey} =0; $hcalc->{$sykey} =0; $hcalc->{$idkey} =0; $hcalc->{$wakey} =0; $hcalc->{$totalkey}=0; Add_Value ($hcalc,$hValOid,$uskey,$kssCpuRawUser); Add_Value ($hcalc,$hValOid,$uskey,$kssCpuRawNice); Add_Value ($hcalc,$hValOid,$sykey,$kssCpuRawSystem); # don't add RawKernel #$hcalc->{$sykey}+=$hValOid->{$kssCpuRawKernel} if (defined($hValOid->{$kssCpuRawKernel})); Add_Value ($hcalc,$hValOid,$idkey,$kssCpuRawIdle); Add_Value ($hcalc,$hValOid,$wakey,$kssCpuRawWait); $hcalc->{$totalkey}=$hcalc->{$uskey} + $hcalc->{$sykey} + $hcalc->{$idkey} + $hcalc->{$wakey}; if ( $opt_verbose ) { # Calculation of Percentages my $us_pct=0; my $sy_pct=0; my $id_pct=0; my $wa_pct=0; if ( $hcalc->{$totalkey} != 0 ) { $us_pct=Round_Number($hcalc->{$uskey} * 100 / $hcalc->{$totalkey},2); $sy_pct=Round_Number($hcalc->{$sykey} * 100 / $hcalc->{$totalkey},2); $id_pct=Round_Number($hcalc->{$idkey} * 100 / $hcalc->{$totalkey},2); $wa_pct=Round_Number($hcalc->{$wakey} * 100 / $hcalc->{$totalkey},2); } printf ("\nValues in timeticks and percent for key:%s\n",$key); printf ("us: %16d, %4.2f%%\n",$hcalc->{$uskey},$us_pct); printf ("sy: %16d, %4.2f%%\n",$hcalc->{$sykey},$sy_pct); printf ("id: %16d, %4.2f%%\n",$hcalc->{$idkey},$id_pct); printf ("wa: %16d, %4.2f%%\n",$hcalc->{$wakey},$wa_pct); printf ("total: %16d\n",$hcalc->{$totalkey}); } } #-------------------------------------------------------------------------- sub Round_Number { #-------------------------------------------------------------------------- my($number,$decimals)=@_; my $mult=10 ** $decimals; my $result=(int(($number * $mult) + 0.5))/$mult; return ($result); } #-------------------------------------------------------------------------- sub get_request { #-------------------------------------------------------------------------- my ($l_oid)=@_; my $l_snmp_result=$snmp_session->get_next_request( -varbindlist => $l_oid, ); #if ( ! defined ($l_snmp_result)) { if ($snmp_session->error_status != 0) { print "ERROR %d get_request: ",$snmp_session->error_status,$snmp_session->error,"\n"; $snmp_session->close; exit $ERRORS{'UNKNOWN'}; } return ($l_snmp_result); } #-------------------------------------------------------------------------- sub print_Single_OIDs { #-------------------------------------------------------------------------- my ($table)=@_; printtable ("UCDAVIS systemStats OIDs"); my $translated; foreach my $key (oid_lex_sort(keys (%{$table}))) { $translated=$key; if (TRANSLATE_OIDs) { $translated=SNMP::translateObj($translated); } printtabular($translated, $table->{$key}); } } #-------------------------------------------------------------------------- sub printtable { #-------------------------------------------------------------------------- my ($l_head)=@_; printf ("\n%-40s\n",$l_head); my $len=length($l_head); my $line="=" x $len; printf ("%-40s\n",$line); } #-------------------------------------------------------------------------- sub printtabular { #-------------------------------------------------------------------------- my ($l_arg,$l_val)=@_; printf ("%-50s: %s\n",$l_arg,$l_val); } #-------------------------------------------------------------------------- sub create_msg { #-------------------------------------------------------------------------- my ($l_txt,$l_msg)=@_; if (! defined $l_txt) {return}; if (defined $$l_msg) { $$l_msg.=", "; } $$l_msg.=$l_txt; } #-------------------------------------------------------------------------- sub check_args { #-------------------------------------------------------------------------- Getopt::Long::Configure('bundling'); GetOptions ("V" => \$opt_version, "version" => \$opt_version, "L" => \$opt_license, "license" => \$opt_license, "v" => \$opt_verbose, "verbose" => \$opt_verbose, "D" => \$opt_snmpdebug, "debug" => \$opt_snmpdebug, "h|?" => \$opt_help, "help" => \$opt_help, "T=i" => \$opt_snmptimeout, "snmptimeout=i" => \$opt_snmptimeout, "t=i" => \$opt_timeout, "timeout=i" => \$opt_timeout, "H=s" => \$opt_hostname, "hostname=s" => \$opt_hostname, "C=s" => \$opt_community, "community=s" => \$opt_community, "p=i" => \$opt_port, "port=i" => \$opt_port, "s=s" => \$opt_snmpvers, "snmpvers=s" => \$opt_snmpvers, "w=s" => \$opt_warn, "warn=s" => \$opt_warn, "c=s" => \$opt_crit, "crit=s" => \$opt_crit, "u=s" => \$opt_username, "username=s" => \$opt_username, "o=s" => \$opt_authpasswd, "authpass=s" => \$opt_authpasswd, "r=s" => \$opt_authproto, "authprot=s" => \$opt_authproto, "O=s" => \$opt_privpasswd, "privpass=s" => \$opt_privpasswd, "R=s" => \$opt_privproto, "privprot=s" => \$opt_privproto, ); if ($opt_license) { print_gpl($PROGNAME,$REVISION); exit $ERRORS{'OK'}; } if ($opt_version) { print_revision($PROGNAME,$REVISION); exit $ERRORS{'OK'}; } if ($opt_help) { print_help(); exit $ERRORS{'OK'}; } if ( ! defined($opt_hostname)){ print "\nERROR: Hostname not defined\n\n"; print_usage(); exit $ERRORS{'UNKNOWN'}; } unless (defined $opt_warn) { print "\nERROR: parameter -w not defined\n\n"; print_usage(); exit ($ERRORS{'UNKNOWN'}); } unless (defined $opt_crit) { print "\nERROR: parameter -c not defined\n\n"; print_usage(); exit ($ERRORS{'UNKNOWN'}); } if ( $opt_warn > $opt_crit) { print "\nERROR: parameter -w greater than parameter -c\n\n"; print_usage(); exit ($ERRORS{'UNKNOWN'}); } unless (defined $opt_snmpvers) { $opt_snmpvers = DEFAULT_SNMPVERS; } if (($opt_snmpvers ne "1") && ($opt_snmpvers ne "2") && ($opt_snmpvers ne "3")) { printf ("\nERROR: SNMP Version %s unknown\n",$opt_snmpvers); print_usage(); exit $ERRORS{'UNKNOWN'}; } unless (defined $opt_timeout) { $opt_timeout = DEFAULT_TIMEOUT; } unless (defined $opt_port) { $opt_port = DEFAULT_PORT; } unless (defined $opt_community) { $opt_community = DEFAULT_COMMUNITY; } if (defined $opt_privpasswd) { unless (defined $opt_privproto) { $opt_privproto = DEFAULT_PRIVPROTO; } } if (defined $opt_authpasswd) { unless (defined $opt_authproto) { $opt_authproto = DEFAULT_AUTHPROTO; } } if ($opt_snmpvers eq "3") { unless (defined $opt_username) { printf ("\nERROR: SNMP Version %s: please define username\n",$opt_snmpvers); print_usage(); exit $ERRORS{'UNKNOWN'}; } } if ($opt_snmpdebug) { $g_snmpdebug = DEBUG_ALL; }else{ $g_snmpdebug = DEBUG_NONE; } unless (defined $opt_snmptimeout) { $opt_snmptimeout = $DEFAULT_SNMPTIMEOUT; } return $ERRORS{'OK'}; } #-------------------------------------------------------------------------- sub print_usage { #-------------------------------------------------------------------------- print "Usage: $PROGNAME [-h] [-L] [-t timeout] [-T ] [-v] [-V] [-C community] [-p port] [-s 1|2|3] -H hostname -w -c \n\n"; print "SNMP version 3 specific: [-u username] [-o authpass] [-r authprot] [-O privpass] [-R privprot]\n"; } #-------------------------------------------------------------------------- sub print_help { #-------------------------------------------------------------------------- print_revision($PROGNAME,$REVISION); printf ("\n"); print_usage(); printf ("\n"); printf (" Check CPU Load via UCD SNMP MIB with optional performance data\n"); printf (" (User, System, Idle, Wait)\n"); printf (" e.g: used on linux in net-snmp agent.\n\n"); printf (" -t (--timeout) Timeout in seconds (default = %d)\n",DEFAULT_TIMEOUT); printf (" -T (--snmptimeout) SNMP CallTimeout in seconds (default = %d)\n",$DEFAULT_SNMPTIMEOUT); printf (" -H (--hostname) Host to monitor\n"); printf (" -s (--snmpvers) SNMP Version [1|2|3] (default = %d)\n",DEFAULT_SNMPVERS); printf (" -C (--community) SNMP Community (default = %s)\n",DEFAULT_COMMUNITY); printf (" -p (--port) SNMP Port (default = %d)\n",DEFAULT_PORT); printf (" -w (--warn) Parameters warning\n"); printf (" -c (--crit) Parameters critical\n"); printf (" -h (--help) Help\n"); printf (" -V (--version) Programm version\n"); printf (" -v (--verbose) Print some useful information\n"); printf (" -L (--license) Print license information\n"); printf ("\nSNMP version 3 specific arguments:\n"); printf (" -u (--username) Security Name\n"); printf (" -o (--authpassword) Authentication password\n"); printf (" -r (--authprotocol) Authentication protocol [md5|sha]\n"); printf (" -O (--privpassword) Privacy password\n"); printf (" -R (--privprotocol) Privacy protocol [des|aes|3des]\n"); printf ("\nThese are percentages of total CPU time.\n"); printf (" us: Time spent running non-kernel code. (user time, including nice time)\n"); printf (" sy: Time spent running kernel code. (system time)\n"); printf (" id: Time spent idle.\n"); printf (" wa: Time spent waiting for IO.\n"); printf ("\n"); } #-------------------------------------------------------------------------- sub print_gpl { #-------------------------------------------------------------------------- print <. EOD } #-------------------------------------------------------------------------- sub print_revision { #-------------------------------------------------------------------------- my ($l_prog,$l_revision)=@_; print < -w -c Plugin collects values (us,sy,id,wa) within 5 seconds and calculates an average cpu usage value. Output looks like (with performance data) CPU OK - No Problems found (32%)|us=24%,sy=8%,id=68%,wa=0% for more information concerning this plugin call: check_cpu_ucd -h perldoc check_cpu_ucd more information concerning the configuration of the UCD SNMP Package: man snmpd.conf =head1 AUTHOR Herbert Stadler, Austria (hestadler@gmx.at) June 2009 This plugin is a contribution to the nagios community. =head1 REQUIRED SOFTWARE from search.cpan.org Net::SNMP Package e.g: Net-SNMP-5.2.0.tar.gz =head1 HOW TO CHECK THE SERVER FUNCTIONALITY Example: snmpwalk -Os -c public -v 1 1.3.6.1.4.1.2021.11 should return some lines like these: ssIndex.0 = INTEGER: 1 ssErrorName.0 = STRING: systemStats ssSwapIn.0 = INTEGER: 0 ssSwapOut.0 = INTEGER: 0 ssIOSent.0 = INTEGER: 0 ssIOReceive.0 = INTEGER: 3 ssSysInterrupts.0 = INTEGER: 4 ssSysContext.0 = INTEGER: 5 ssCpuUser.0 = INTEGER: 1 ssCpuSystem.0 = INTEGER: 3 ssCpuIdle.0 = INTEGER: 95 ssCpuRawUser.0 = Counter32: 8357178 ssCpuRawNice.0 = Counter32: 587 ssCpuRawSystem.0 = Counter32: 42816056 ssCpuRawIdle.0 = Counter32: 646281090 ssCpuRawWait.0 = Counter32: 29232561 ssCpuRawKernel.0 = Counter32: 25317769 ssCpuRawInterrupt.0 = Counter32: 895206 ssIORawSent.0 = Counter32: 3264259202 ssIORawReceived.0 = Counter32: 1935288426 ssRawInterrupts.0 = Counter32: 1961869159 ssRawContexts.0 = Counter32: 3639542339 ssCpuRawSoftIRQ.0 = Counter32: 16603081 ssRawSwapIn.0 = Counter32: 0 ssRawSwapOut.0 = Counter32: 85 if not, check: - the configuration file (on linux /etc/snmp/snmpd.conf) - check net-snmp version if bugs available =head1 CONFIGURATION IN NAGIOS Copy this plugin to the nagios plugin installation directory e.g.: /usr/lib(64)/nagios/plugin COMMAND DEFINITION: # "check_cpu_ucd" command definition define command{ command_name check_cpu_ucd command_line $USER1$/check_cpu_ucd -H $HOSTADDRESS$ -w $ARG1$ -c $ARG2$ } =head1 PLUGIN HISTORY Version 1.0 - 2009-06-17 first release Version 1.1 - 2010-03-01 Illegal division by zero corrected Version 1.2 - 2010-03-24 check error_status of snmp call =head1 COPYRIGHT AND DISCLAIMER Copyright (C) 2009 by Herbert Stadler email: hestadler@gmx.at License Information: 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; either version 3 of the License, or (at your option) any later version. 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, see . =cut