renamed module into Monitoring::Plugin

since the complete monitoring team has been renamed, we
also rename this module.

Signed-off-by: Sven Nierlein <sven@nierlein.de>

9 files changed, 436 insertions, 419 deletions

diff --git a/lib/Nagios/Plugin.pm b/lib/Monitoring/Plugin.pm
index d85d35a..f9eb49e 100644
--- a/lib/Nagios/Plugin.pm
+++ b/lib/Monitoring/Plugin.pm
@@ -1,7 +1,7 @@
 
-package Nagios::Plugin;
+package Monitoring::Plugin;
 
-use Nagios::Plugin::Functions qw(:codes %ERRORS %STATUS_TEXT @STATUS_CODES);
+use Monitoring::Plugin::Functions qw(:codes %ERRORS %STATUS_TEXT @STATUS_CODES);
 use Params::Validate qw(:all);
 
 use strict;
@@ -10,10 +10,10 @@ use warnings;
 use Carp;
 use base qw(Class::Accessor::Fast);
 
-Nagios::Plugin->mk_accessors(qw(
+Monitoring::Plugin->mk_accessors(qw(
                                                                 shortname
-                                                                perfdata 
-                                                                messages 
+                                                                perfdata
+                                                                messages
                                                                 opts
                                                                 threshold
                                                                 ));
@@ -25,8 +25,8 @@ our @EXPORT_OK = qw(%ERRORS %STATUS_TEXT);
 
 # CPAN stupidly won't index this module without a literal $VERSION here,
 #   so we're forced to duplicate it explicitly
-# Make sure you update $Nagios::Plugin::Functions::VERSION too
-our $VERSION = "0.36";
+# Make sure you update $Monitoring::Plugin::Functions::VERSION too
+our $VERSION = "0.37";
 
 sub new {
         my $class = shift;
@@ -46,7 +46,7 @@ sub new {
                 },
         );
 
-        my $shortname = Nagios::Plugin::Functions::get_shortname(\%args);
+        my $shortname = Monitoring::Plugin::Functions::get_shortname(\%args);
         delete $args{shortname} if (exists $args{shortname});
         my $self = {
                 shortname => $shortname,
@@ -61,16 +61,16 @@ sub new {
         };
         bless $self, $class;
         if (exists $args{usage}) {
-                require Nagios::Plugin::Getopt;
-                $self->opts( new Nagios::Plugin::Getopt(%args) );
+                require Monitoring::Plugin::Getopt;
+                $self->opts( new Monitoring::Plugin::Getopt(%args) );
         }
         return $self;
 }
 
 sub add_perfdata {
     my ($self, %args) = @_;
-    require Nagios::Plugin::Performance;
-    my $perf = Nagios::Plugin::Performance->new(%args);
+    require Monitoring::Plugin::Performance;
+    my $perf = Monitoring::Plugin::Performance->new(%args);
     push @{$self->perfdata}, $perf;
 }
 sub all_perfoutput {
@@ -78,33 +78,41 @@ sub all_perfoutput {
     return join(" ", map {$_->perfoutput} (@{$self->perfdata}));
 }
 
-sub set_thresholds { 
-    my $self = shift; 
-    require Nagios::Plugin::Threshold;
-    return $self->threshold( Nagios::Plugin::Threshold->set_thresholds(@_)); 
+sub set_thresholds {
+    my $self = shift;
+    require Monitoring::Plugin::Threshold;
+    return $self->threshold( Monitoring::Plugin::Threshold->set_thresholds(@_));
 }
 
-# NP::Functions wrappers
+# MP::Functions wrappers
+sub plugin_exit {
+    my $self = shift;
+    Monitoring::Plugin::Functions::plugin_exit(@_, { plugin => $self });
+}
+sub plugin_die {
+    my $self = shift;
+    Monitoring::Plugin::Functions::plugin_die(@_, { plugin => $self });
+}
 sub nagios_exit {
     my $self = shift;
-    Nagios::Plugin::Functions::nagios_exit(@_, { plugin => $self });
+    Monitoring::Plugin::Functions::plugin_exit(@_, { plugin => $self });
 }
 sub nagios_die {
     my $self = shift;
-    Nagios::Plugin::Functions::nagios_die(@_, { plugin => $self });
+    Monitoring::Plugin::Functions::plugin_die(@_, { plugin => $self });
 }
 sub die {
     my $self = shift;
-    Nagios::Plugin::Functions::nagios_die(@_, { plugin => $self });
+    Monitoring::Plugin::Functions::plugin_die(@_, { plugin => $self });
 }
 sub max_state {
-    Nagios::Plugin::Functions::max_state(@_);
+    Monitoring::Plugin::Functions::max_state(@_);
 }
 sub max_state_alt {
-    Nagios::Plugin::Functions::max_state_alt(@_);
+    Monitoring::Plugin::Functions::max_state_alt(@_);
 }
 
-# top level interface to Nagios::Plugin::Threshold
+# top level interface to Monitoring::Plugin::Threshold
 sub check_threshold {
         my $self = shift;
 
@@ -143,11 +151,11 @@ sub check_threshold {
         else {
                 return UNKNOWN;
         }
-        
+
         return $self->threshold->get_status($args{check});
 }
 
-# top level interface to my Nagios::Plugin::Getopt object
+# top level interface to my Monitoring::Plugin::Getopt object
 sub add_arg {
     my $self = shift;
         $self->opts->arg(@_) if $self->_check_for_opts;
@@ -160,15 +168,15 @@ sub getopts {
 sub _check_for_opts {
         my $self = shift;
         croak
-                "You have to supply a 'usage' param to Nagios::Plugin::new() if you want to use Getopts from your Nagios::Plugin object."
-                        unless ref $self->opts() eq 'Nagios::Plugin::Getopt';
+                "You have to supply a 'usage' param to Monitoring::Plugin::new() if you want to use Getopts from your Monitoring::Plugin object."
+                        unless ref $self->opts() eq 'Monitoring::Plugin::Getopt';
         return $self;
 }
 
 
 
 # -------------------------------------------------------------------------
-# NP::Functions::check_messages helpers and wrappers
+# MP::Functions::check_messages helpers and wrappers
 
 sub add_message {
     my $self = shift;
@@ -179,7 +187,7 @@ sub add_message {
 
     # Store messages using strings rather than numeric codes
     $code = $STATUS_TEXT{$code} if $STATUS_TEXT{$code};
-    $code = lc $code; 
+    $code = lc $code;
     croak "Error code '$code' not supported by add_message"
         if $code eq 'unknown' || $code eq 'dependent';
 
@@ -199,7 +207,7 @@ sub check_messages {
                 if ($code eq 'ok') {
                     $args{$code} = [ $args{$code} ];
                 } else {
-                    croak "Invalid argument '$code'" 
+                    croak "Invalid argument '$code'"
                 }
             }
             push @{$args{$code}}, @$messages;
@@ -209,7 +217,7 @@ sub check_messages {
         }
     }
 
-    Nagios::Plugin::Functions::check_messages(%args);
+    Monitoring::Plugin::Functions::check_messages(%args);
 }
 
 # -------------------------------------------------------------------------
@@ -222,23 +230,23 @@ __END__
 
 =head1 NAME
 
-Nagios::Plugin - A family of perl modules to streamline writing Nagios 
-plugins
+Monitoring::Plugin - A family of perl modules to streamline writing Naemon, Nagios,
+Icinga or Shinken (and compatible) plugins.
 
 =head1 SYNOPSIS
 
    # Constants OK, WARNING, CRITICAL, and UNKNOWN are exported by default
-   # See also Nagios::Plugin::Functions for a functional interface
-   use Nagios::Plugin;
+   # See also Monitoring::Plugin::Functions for a functional interface
+   use Monitoring::Plugin;
 
    # Constructor
-   $np = Nagios::Plugin->new;                               # OR
-   $np = Nagios::Plugin->new( shortname => "PAGESIZE" );    # OR
+   $np = Monitoring::Plugin->new;                               # OR
+   $np = Monitoring::Plugin->new( shortname => "PAGESIZE" );    # OR
 
 
-   # use Nagios::Plugin::Getopt to process the @ARGV command line options:
+   # use Monitoring::Plugin::Getopt to process the @ARGV command line options:
    #   --verbose, --help, --usage, --timeout and --host are defined automatically.
-   $np = Nagios::Plugin->new(  
+   $np = Monitoring::Plugin->new(
      usage => "Usage: %s [ -v|--verbose ]  [-H <host>] [-t <timeout>] "
        . "[ -c|--critical=<threshold> ] [ -w|--warning=<threshold> ]",
    );
@@ -247,7 +255,7 @@ plugins
    $np->add_arg(
      spec => 'warning|w=s',
      help => '-w, --warning=INTEGER:INTEGER .  See '
-       . 'http://nagiosplug.sourceforge.net/developer-guidelines.html#THRESHOLDFORMAT '
+       . 'https://www.monitoring-plugins.org/doc/guidelines.html#THRESHOLDFORMAT '
        . 'for the threshold format. ',
    );
 
@@ -255,29 +263,29 @@ plugins
    $np->getopts;
 
 
-   # Exit/return value methods - nagios_exit( CODE, MESSAGE ), 
-   #                             nagios_die( MESSAGE, [CODE])
+   # Exit/return value methods - plugin_exit( CODE, MESSAGE ),
+   #                             plugin_die( MESSAGE, [CODE])
    $page = retrieve_page($page1)
-       or $np->nagios_exit( UNKNOWN, "Could not retrieve page" );
-       # Return code: 3; 
-       #   output: PAGESIZE UNKNOWN - Could not retrieve page 
+       or $np->plugin_exit( UNKNOWN, "Could not retrieve page" );
+       # Return code: 3;
+       #   output: PAGESIZE UNKNOWN - Could not retrieve page
    test_page($page)
-       or $np->nagios_exit( CRITICAL, "Bad page found" );
+       or $np->plugin_exit( CRITICAL, "Bad page found" );
 
-   # nagios_die() is just like nagios_exit(), but return code defaults 
+   # plugin_die() is just like plugin_exit(), but return code defaults
    #   to UNKNOWN
    $page = retrieve_page($page2)
-     or $np->nagios_die( "Could not retrieve page" );
-     # Return code: 3; 
+     or $np->plugin_die( "Could not retrieve page" );
+     # Return code: 3;
      #   output: PAGESIZE UNKNOWN - Could not retrieve page
 
-   # Threshold methods 
+   # Threshold methods
    $code = $np->check_threshold(
      check => $value,
      warning => $warning_threshold,
      critical => $critical_threshold,
    );
-   $np->nagios_exit( $code, "Threshold check failed" ) if $code != OK;
+   $np->plugin_exit( $code, "Threshold check failed" ) if $code != OK;
 
 
    # Message methods (EXPERIMENTAL AND SUBJECT TO CHANGE) -
@@ -290,38 +298,38 @@ plugins
      }
    }
    ($code, $message) = $np->check_messages();
-   nagios_exit( $code, $message );
-   # If any items in collection matched m/Error/, returns CRITICAL and 
-   #   the joined set of Error messages; otherwise returns OK and the 
+   plugin_exit( $code, $message );
+   # If any items in collection matched m/Error/, returns CRITICAL and
+   #   the joined set of Error messages; otherwise returns OK and the
    #   joined set of ok messages
 
 
    # Perfdata methods
-   $np->add_perfdata( 
+   $np->add_perfdata(
      label => "size",
      value => $value,
      uom => "kB",
      threshold => $threshold,
    );
    $np->add_perfdata( label => "time", ... );
-   $np->nagios_exit( OK, "page size at http://... was ${value}kB" );
-   # Return code: 0; 
+   $np->plugin_exit( OK, "page size at http://... was ${value}kB" );
+   # Return code: 0;
    #   output: PAGESIZE OK - page size at http://... was 36kB \
    #   | size=36kB;10:25;25: time=...
 
 
 =head1 DESCRIPTION
 
-Nagios::Plugin and its associated Nagios::Plugin::* modules are a
-family of perl modules to streamline writing Nagios plugins. The main
-end user modules are Nagios::Plugin, providing an object-oriented
-interface to the entire Nagios::Plugin::* collection, and
-Nagios::Plugin::Functions, providing a simpler functional interface to
+Monitoring::Plugin and its associated Monitoring::Plugin::* modules are a
+family of perl modules to streamline writing Monitoring plugins. The main
+end user modules are Monitoring::Plugin, providing an object-oriented
+interface to the entire Monitoring::Plugin::* collection, and
+Monitoring::Plugin::Functions, providing a simpler functional interface to
 a useful subset of the available functionality.
 
 The purpose of the collection is to make it as simple as possible for
-developers to create plugins that conform the Nagios Plugin guidelines
-(http://nagiosplug.sourceforge.net/developer-guidelines.html).
+developers to create plugins that conform the Monitoring Plugin guidelines
+(https://www.monitoring-plugins.org/doc/guidelines.html).
 
 
 =head2 EXPORTS
@@ -346,7 +354,7 @@ corresponding status code.
 =item %STATUS_TEXT
 
 A hash mapping status code constants (OK, WARNING, CRITICAL, etc.) to the
-corresponding error string ("OK", "WARNING, "CRITICAL", etc.) i.e. the 
+corresponding error string ("OK", "WARNING, "CRITICAL", etc.) i.e. the
 reverse of %ERRORS.
 
 =back
@@ -354,11 +362,11 @@ reverse of %ERRORS.
 
 =head2 CONSTRUCTOR
 
-        Nagios::Plugin->new;
+        Monitoring::Plugin->new;
 
-        Nagios::Plugin->new( shortname => 'PAGESIZE' );
+        Monitoring::Plugin->new( shortname => 'PAGESIZE' );
 
-        Nagios::Plugin->new(
+        Monitoring::Plugin->new(
                 usage => "Usage: %s [ -v|--verbose ]  [-H <host>] [-t <timeout>]
                      [ -c|--critical=<critical threshold> ] [ -w|--warning=<warning threshold> ]  ",
                 version => $VERSION,
@@ -370,7 +378,7 @@ reverse of %ERRORS.
                 timeout => 15,
         );
 
-Instantiates a new Nagios::Plugin object. Accepts the following named
+Instantiates a new Monitoring::Plugin object. Accepts the following named
 arguments:
 
 =over 4
@@ -382,10 +390,10 @@ output by the various exit methods. Default: uc basename $0.
 
 =item usage ("Usage:  %s --foo --bar")
 
-Passing a value for the usage() argument makes Nagios::Plugin
-instantiate its own C<Nagios::Plugin::Getopt> object so you can start
+Passing a value for the usage() argument makes Monitoring::Plugin
+instantiate its own C<Monitoring::Plugin::Getopt> object so you can start
 doing command line argument processing.  See
-L<Nagios::Plugin::Getopt/CONSTRUCTOR> for more about "usage" and the
+L<Monitoring::Plugin::Getopt/CONSTRUCTOR> for more about "usage" and the
 following options:
 
 =item version
@@ -406,7 +414,7 @@ following options:
 
 =head2 OPTION HANDLING METHODS
 
-C<Nagios::Plugin> provides these methods for accessing the functionality in C<Nagios::Plugin::Getopt>.
+C<Monitoring::Plugin> provides these methods for accessing the functionality in C<Monitoring::Plugin::Getopt>.
 
 =over 4
 
@@ -416,7 +424,7 @@ Examples:
 
   # Define --hello argument (named parameters)
   $plugin->add_arg(
-    spec => 'hello=s', 
+    spec => 'hello=s',
     help => "--hello\n   Hello string",
     required => 1,
   );
@@ -425,19 +433,19 @@ Examples:
   #   Parameter order is 'spec', 'help', 'default', 'required?'
   $plugin->add_arg('hello=s', "--hello\n   Hello string", undef, 1);
 
-See L<Nagios::Plugin::Getopt/ARGUMENTS> for more details.
+See L<Monitoring::Plugin::Getopt/ARGUMENTS> for more details.
 
 =item getopts()
 
 Parses and processes the command line options you've defined,
 automatically doing the right thing with help/usage/version arguments.
 
-See  L<Nagios::Plugin::Getopt/GETOPTS> for more details.
+See  L<Monitoring::Plugin::Getopt/GETOPTS> for more details.
 
 =item opts()
 
 Assuming you've instantiated it by passing 'usage' to new(), opts()
-returns the Nagios::Plugin object's C<Nagios::Plugin::Getopt> object,
+returns the Monitoring::Plugin object's C<Monitoring::Plugin::Getopt> object,
 with which you can do lots of great things.
 
 E.g.
@@ -456,7 +464,7 @@ E.g.
   #   $plugin->getopts;
   print $plugin->opts->my_argument;
 
-Again, see L<Nagios::Plugin::Getopt>.
+Again, see L<Monitoring::Plugin::Getopt>.
 
 =back
 
@@ -464,33 +472,41 @@ Again, see L<Nagios::Plugin::Getopt>.
 
 =over 4
 
-=item nagios_exit( <CODE>, $message )
+=item plugin_exit( <CODE>, $message )
 
 Exit with return code CODE, and a standard nagios message of the
 form "SHORTNAME CODE - $message".
 
-=item nagios_die( $message, [<CODE>] )
+=item plugin_die( $message, [<CODE>] )
 
-Same as nagios_exit(), except that CODE is optional, defaulting
+Same as plugin_exit(), except that CODE is optional, defaulting
 to UNKNOWN.  NOTE: exceptions are not raised by default to calling code.
 Set C<$_use_die> flag if this functionality is required (see test code).
 
+=item nagios_exit( <CODE>, $message )
+
+Alias for plugin_die(). Deprecated.
+
+=item nagios_die( $message, [<CODE>] )
+
+Alias for plugin_die(). Deprecated.
+
 =item die( $message, [<CODE>] )
 
-Alias for nagios_die(). Deprecated.
+Alias for plugin_die(). Deprecated.
 
 =item max_state, max_state_alt
 
-These are wrapper function for Nagios::Plugin::Functions::max_state and
-Nagios::Plugin::Functions::max_state_alt.
+These are wrapper function for Monitoring::Plugin::Functions::max_state and
+Monitoring::Plugin::Functions::max_state_alt.
 
 =back
 
 =head2 THRESHOLD METHODS
 
 These provide a top level interface to the
-C<Nagios::Plugin::Threshold> module; for more details, see
-L<Nagios::Plugin::Threshold> and L<Nagios::Plugin::Range>.
+C<Monitoring::Plugin::Threshold> module; for more details, see
+L<Monitoring::Plugin::Threshold> and L<Monitoring::Plugin::Range>.
 
 =over 4
 
@@ -512,9 +528,9 @@ WARNING constant.  The thresholds may be:
 You can specify $value as an array of values and each will be checked against
 the thresholds.
 
-The return value is ready to pass to C <nagios_exit>, e . g .,
+The return value is ready to pass to C <plugin_exit>, e . g .,
 
-  $p->nagios_exit(
+  $p->plugin_exit(
         return_code => $p->check_threshold($result),
         message     => " sample result was $result"
   );
@@ -523,13 +539,13 @@ The return value is ready to pass to C <nagios_exit>, e . g .,
 =item set_thresholds(warning => "10:25", critical => "~:25")
 
 Sets the acceptable ranges and creates the plugin's
-Nagios::Plugins::Threshold object.  See
-http://nagiosplug.sourceforge.net/developer-guidelines.html#THRESHOLDFORMAT
+Monitoring::Plugins::Threshold object.  See
+https://www.monitoring-plugins.org/doc/guidelines.html#THRESHOLDFORMAT
 for details and examples of the threshold format.
 
 =item threshold()
 
-Returns the object's C<Nagios::Plugin::Threshold> object, if it has
+Returns the object's C<Monitoring::Plugin::Threshold> object, if it has
 been defined by calling set_thresholds().  You can pass a new
 Threshold object to it to replace the old one too, but you shouldn't
 need to do that from a plugin script.
@@ -543,17 +559,17 @@ EXPERIMENTAL AND SUBJECT TO CHANGE
 add_messages and check_messages are higher-level convenience methods to add
 and then check a set of messages, returning an appropriate return code
 and/or result message. They are equivalent to maintaining a set of @critical,
-@warning, and and @ok message arrays (add_message), and then doing a final 
+@warning, and and @ok message arrays (add_message), and then doing a final
 if test (check_messages) like this:
 
   if (@critical) {
-    nagios_exit( CRITICAL, join(' ', @critical) );
-  } 
+    plugin_exit( CRITICAL, join(' ', @critical) );
+  }
   elsif (@warning) {
-    nagios_exit( WARNING, join(' ', @warning) );
+    plugin_exit( WARNING, join(' ', @warning) );
   }
   else {
-    nagios_exit( OK, join(' ', @ok) );
+    plugin_exit( OK, join(' ', @ok) );
   }
 
 =over 4
@@ -571,7 +587,7 @@ Only CRITICAL, WARNING, and OK are accepted as valid codes.
 Check the current set of messages and return an appropriate nagios return
 code and/or a result message. In scalar context, returns only a return
 code; in list context returns both a return code and an output message,
-suitable for passing directly to nagios_exit() e.g.
+suitable for passing directly to plugin_exit() e.g.
 
     $code = $np->check_messages;
     ($code, $message) = $np->check_messages;
@@ -587,7 +603,7 @@ check_messages accepts the following named arguments (none are required):
 
 =item join => SCALAR
 
-A string used to join the relevant array to generate the message 
+A string used to join the relevant array to generate the message
 string returned in list context i.e. if the 'critical' array @crit
 is non-empty, check_messages would return:
 
@@ -599,9 +615,9 @@ as the result message. Default: ' ' (space).
 
 By default, only one set of messages are joined and returned in the
 result message i.e. if the result is CRITICAL, only the 'critical'
-messages are included in the result; if WARNING, only the 'warning' 
+messages are included in the result; if WARNING, only the 'warning'
 messages are included; if OK, the 'ok' messages are included (if
-supplied) i.e. the default is to return an 'errors-only' type 
+supplied) i.e. the default is to return an 'errors-only' type
 message.
 
 If join_all is supplied, however, it will be used as a string to
@@ -635,10 +651,10 @@ Add a set of performance data to the object. May be called multiple times.
 The performance data is included in the standard plugin output messages by
 the various exit methods.
 
-See the Nagios::Plugin::Performance documentation for more information on
+See the Monitoring::Plugin::Performance documentation for more information on
 performance data and the various field definitions, as well as the relevant
-section of the Nagios Plugin guidelines
-(http://nagiosplug.sourceforge.net/developer-guidelines.html#AEN202).
+section of the Monitoring Plugin guidelines
+(https://www.monitoring-plugins.org/doc/guidelines.html#AEN202).
 
 =back
 
@@ -648,50 +664,49 @@ section of the Nagios Plugin guidelines
 "Enough talk!  Show me some examples!"
 
 See the file 'check_stuff.pl' in the 't' directory included with the
-Nagios::Plugin distribution for a complete working example of a plugin
+Monitoring::Plugin distribution for a complete working example of a plugin
 script.
 
 
 =head1 VERSIONING
 
-The Nagios::Plugin::* modules are currently experimental and so the
-interfaces may change up until Nagios::Plugin hits version 1.0, although
+The Monitoring::Plugin::* modules are currently experimental and so the
+interfaces may change up until Monitoring::Plugin hits version 1.0, although
 every attempt will be made to keep them as backwards compatible as
 possible.
 
 
 =head1 SEE ALSO
 
-See L<Nagios::Plugin::Functions> for a simple functional interface to a subset
-of the available Nagios::Plugin functionality.
+See L<Monitoring::Plugin::Functions> for a simple functional interface to a subset
+of the available Monitoring::Plugin functionality.
 
-See also L<Nagios::Plugin::Getopt>, L<Nagios::Plugin::Range>,
-L<Nagios::Plugin::Performance>, L<Nagios::Plugin::Range>, and
-L<Nagios::Plugin::Threshold>.
+See also L<Monitoring::Plugin::Getopt>, L<Monitoring::Plugin::Range>,
+L<Monitoring::Plugin::Performance>, L<Monitoring::Plugin::Range>, and
+L<Monitoring::Plugin::Threshold>.
 
-The Nagios Plugin project page is at http://nagiosplug.sourceforge.net.
+The Monitoring Plugin project page is at http://monitoring-plugins.org.
 
 
 =head1 BUGS
 
-Please report bugs in these modules to the Nagios Plugin development team:
-nagiosplug-devel@lists.sourceforge.net.
+Please report bugs in these modules to the Monitoring Plugin development team:
+devel@monitoring-plugins.org.
 
 
 =head1 AUTHOR
 
-Maintained by the Nagios Plugin development team -
-http://nagiosplug.sourceforge.net.
+Maintained by the Monitoring Plugin development team -
+https://www.monitoring-plugins.org.
 
 Originally by Ton Voon, E<lt>ton.voon@altinity.comE<gt>.
 
 =head1 COPYRIGHT AND LICENSE
 
-Copyright (C) 2006 by Nagios Plugin Development Team
+Copyright (C) 2006-2014 by Monitoring Plugin Team
 
 This library is free software; you can redistribute it and/or modify it
 under the same terms as Perl itself, either Perl version 5.8.4 or, at your
 option, any later version of Perl 5 you may have available.
 
 =cut
-
diff --git a/lib/Nagios/Plugin/Config.pm b/lib/Monitoring/Plugin/Config.pm
index dd270e9..5e941d4 100644
--- a/lib/Nagios/Plugin/Config.pm
+++ b/lib/Monitoring/Plugin/Config.pm
@@ -1,4 +1,4 @@
-package Nagios::Plugin::Config;
+package Monitoring::Plugin::Config;
 
 use strict;
 use Carp;
@@ -7,10 +7,11 @@ use base qw(Config::Tiny);
 
 my $FILENAME1 = 'plugins.ini';
 my $FILENAME2 = 'nagios-plugins.ini';
+my $FILENAME3 = 'monitoring-plugins.ini';
 my $CURRENT_FILE = undef;
 
 # Config paths ending in nagios (search for $FILENAME1)
-my @NAGIOS_CONFIG_PATH = qw(/etc/nagios /usr/local/nagios/etc /usr/local/etc/nagios /etc/opt/nagios);
+my @MONITORING_CONFIG_PATH = qw(/etc/nagios /usr/local/nagios/etc /usr/local/etc/nagios /etc/opt/nagios);
 # Config paths not ending in nagios (search for $FILENAME2)
 my @CONFIG_PATH = qw(/etc /usr/local/etc /etc/opt);
 
@@ -21,26 +22,30 @@ sub read
 
         unless ($_[0]) {
                 SEARCH: {
-                       if ($ENV{NAGIOS_CONFIG_PATH}) {
-                               for (split /:/, $ENV{NAGIOS_CONFIG_PATH}) {
+                       if ($ENV{MONITORING_CONFIG_PATH} || $ENV{NAGIOS_CONFIG_PATH}) {
+                               for (split /:/, ($ENV{MONITORING_CONFIG_PATH} || $ENV{NAGIOS_CONFIG_PATH})) {
                                        my $file = File::Spec->catfile($_, $FILENAME1);
                                        unshift(@_, $file), last SEARCH if -f $file;
                                        $file = File::Spec->catfile($_, $FILENAME2);
                                        unshift(@_, $file), last SEARCH if -f $file;
+                                       $file = File::Spec->catfile($_, $FILENAME3);
+                                       unshift(@_, $file), last SEARCH if -f $file;
                                }
                        }
-                       for (@NAGIOS_CONFIG_PATH) {
+                       for (@MONITORING_CONFIG_PATH) {
                                my $file = File::Spec->catfile($_, $FILENAME1);
                                unshift(@_, $file), last SEARCH if -f $file;
                        }
                        for (@CONFIG_PATH) {
                                my $file = File::Spec->catfile($_, $FILENAME2);
                                unshift(@_, $file), last SEARCH if -f $file;
+                               $file = File::Spec->catfile($_, $FILENAME3);
+                               unshift(@_, $file), last SEARCH if -f $file;
                        }
                 }
 
                 # Use die instead of croak, so we can pass a clean message downstream
-                die "Cannot find '$FILENAME1' or '$FILENAME2' in any standard location.\n" unless $_[0];
+                die "Cannot find '$FILENAME1', '$FILENAME2' or '$FILENAME3' in any standard location.\n" unless $_[0];
         }
 
         $CURRENT_FILE = $_[0];
@@ -94,15 +99,15 @@ sub np_getfile { return $CURRENT_FILE; }
 
 =head1 NAME
 
-Nagios::Plugin::Config - read nagios plugin .ini style config files
+Monitoring::Plugin::Config - read nagios plugin .ini style config files
 
 =head1 SYNOPSIS
 
     # Read given nagios plugin config file
-    $Config = Nagios::Plugin::Config->read( '/etc/nagios/plugins.ini' );
+    $Config = Monitoring::Plugin::Config->read( '/etc/nagios/plugins.ini' );
 
     # Search for and read default nagios plugin config file
-    $Config = Nagios::Plugin::Config->read();
+    $Config = Monitoring::Plugin::Config->read();
 
     # Access sections and properties (returns scalars or arrayrefs)
     $rootproperty =  $Config->{_}->{rootproperty};
@@ -111,22 +116,22 @@ Nagios::Plugin::Config - read nagios plugin .ini style config files
 
 =head1 DESCRIPTION
 
-Nagios::Plugin::Config is a subclass of the excellent Config::Tiny,
+Monitoring::Plugin::Config is a subclass of the excellent Config::Tiny,
 with the following changes:
 
 =over 4
 
-=item 
+=item
 
 Repeated keys are allowed within sections, returning lists instead of scalars
 
-=item 
+=item
 
 Write functionality has been removed i.e. access is read only
 
-=item 
+=item
 
-Nagios::Plugin::Config searches for a default nagios plugins file if no explicit 
+Monitoring::Plugin::Config searches for a default nagios plugins file if no explicit
 filename is given to C<read()>. The current standard locations checked are:
 
 =over 4
@@ -137,15 +142,15 @@ filename is given to C<read()>. The current standard locations checked are:
 
 =item /usr/local/etc/nagios /etc/opt/nagios/plugins.ini
 
-=item /etc/nagios-plugins.ini 
+=item /etc/nagios-plugins.ini
 
-=item /usr/local/etc/nagios-plugins.ini 
+=item /usr/local/etc/nagios-plugins.ini
 
 =item /etc/opt/nagios-plugins.ini
 
 =back
 
-To use a custom location, set a C<NAGIOS_CONFIG_PATH> environment variable 
+To use a custom location, set a C<NAGIOS_CONFIG_PATH> environment variable
 to the set of directories that should be checked. The first C<plugins.ini> or
 C<nagios-plugins.ini> file found will be used.
 
@@ -154,21 +159,19 @@ C<nagios-plugins.ini> file found will be used.
 
 =head1 SEE ALSO
 
-L<Config::Tiny>, L<Nagios::Plugin>
+L<Config::Tiny>, L<Monitoring::Plugin>
 
 
-=head1 AUTHORS
+=head1 AUTHOR
 
-This code is maintained by the Nagios Plugin Development Team: 
-L<http://nagiosplug.sourceforge.net>.
+This code is maintained by the Monitoring Plugin Development Team: see
+https://monitoring-plugins.org
 
+=head1 COPYRIGHT AND LICENSE
 
-=head1 COPYRIGHT and LICENCE
-
-Copyright (C) 2006-2007 by Nagios Plugin Development Team
+Copyright (C) 2006-2014 Monitoring Plugin Development Team
 
 This library is free software; you can redistribute it and/or modify
 it under the same terms as Perl itself.
 
 =cut
-
diff --git a/lib/Monitoring/Plugin/ExitResult.pm b/lib/Monitoring/Plugin/ExitResult.pm
new file mode 100644
index 0000000..aa9f5da
--- /dev/null
+++ b/lib/Monitoring/Plugin/ExitResult.pm
@@ -0,0 +1,71 @@
+# Tiny helper class to return both output and return_code when testing
+
+package Monitoring::Plugin::ExitResult;
+
+use strict;
+
+# Stringify to message
+use overload '""' => sub { shift->{message} };
+
+# Constructor
+sub new {
+    my $class = shift;
+    return bless { return_code => $_[0], message => $_[1] }, $class;
+}
+
+# Accessors
+sub message { shift->{message} }
+sub return_code { shift->{return_code} }
+sub code { shift->{return_code} }
+
+1;
+
+__END__
+
+=head1 NAME
+
+Monitoring::Plugin::ExitResult - Helper class for returning both output and
+return codes when testing.
+
+=head1 SYNOPSIS
+
+    use Test::More;
+    use Monitoring::Plugin::Functions;
+
+    # In a test file somewhere
+    Monitoring::Plugin::Functions::_fake_exit(1);
+
+    # Later ...
+    $e = plugin_exit( CRITICAL, 'aiiii ...' );
+    print $e->message;
+    print $e->return_code;
+
+    # MP::ExitResult also stringifies to the message output
+    like(plugin_exit( WARNING, 'foobar'), qr/^foo/, 'matches!');
+
+
+
+=head1 DESCRIPTION
+
+Monitoring::Plugin::ExitResult is a tiny helper class intended for use
+when testing other Monitoring::Plugin modules. A Monitoring::Plugin::ExitResult
+object is returned by plugin_exit() and friends when
+Monitoring::Plugin::Functions::_fake_exit has been set, instead of doing a
+conventional print + exit.
+
+=head1 AUTHOR
+
+This code is maintained by the Monitoring Plugin Development Team: see
+https://monitoring-plugins.org
+
+Originally:
+    Gavin Carr , E<lt>gavin@openfusion.com.auE<gt>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (C) 2006-2014 Monitoring Plugin Development Team
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
+
+=cut
diff --git a/lib/Nagios/Plugin/Functions.pm b/lib/Monitoring/Plugin/Functions.pm
index 14fe661..d2856e8 100644
--- a/lib/Nagios/Plugin/Functions.pm
+++ b/lib/Monitoring/Plugin/Functions.pm
@@ -1,7 +1,7 @@
-# Functional interface to basic Nagios::Plugin constants, exports, 
+# Functional interface to basic Monitoring::Plugin constants, exports,
 # and functions
 
-package Nagios::Plugin::Functions;
+package Monitoring::Plugin::Functions;
 
 use 5.006;
 
@@ -11,19 +11,19 @@ use File::Basename;
 use Params::Validate qw(:types validate);
 use Math::Calc::Units;
 
-# Remember to update Nagios::Plugins as well
-our $VERSION = "0.36";
+# Remember to update Monitoring::Plugins as well
+our $VERSION = "0.37";
 
 our @STATUS_CODES = qw(OK WARNING CRITICAL UNKNOWN DEPENDENT);
 
 require Exporter;
 our @ISA = qw(Exporter);
-our @EXPORT = (@STATUS_CODES, qw(nagios_exit nagios_die check_messages));
+our @EXPORT = (@STATUS_CODES, qw(plugin_exit plugin_die check_messages));
 our @EXPORT_OK = qw(%ERRORS %STATUS_TEXT @STATUS_CODES get_shortname max_state max_state_alt convert $value_re);
 our %EXPORT_TAGS = (
     all => [ @EXPORT, @EXPORT_OK ],
     codes => [ @STATUS_CODES ],
-    functions => [ qw(nagios_exit nagios_die check_messages max_state max_state_alt convert) ],
+    functions => [ qw(plugin_exit plugin_die check_messages max_state max_state_alt convert) ],
 );
 
 use constant OK         => 0;
@@ -61,7 +61,7 @@ sub get_shortname {
     return $arg->{shortname} if (defined($arg->{shortname}));
     $shortname = $arg->{plugin} if (defined( $arg->{plugin}));
 
-    $shortname = uc basename($shortname || $ENV{NAGIOS_PLUGIN} || $0);
+    $shortname = uc basename($shortname || $ENV{PLUGIN_NAME} || $ENV{NAGIOS_PLUGIN} || $0);
     $shortname =~ s/^CHECK_(?:BY_)?//;     # Remove any leading CHECK_[BY_]
     $shortname =~ s/\..*$//;       # Remove any trailing suffix
     return $shortname;
@@ -85,8 +85,8 @@ sub max_state_alt {
         return UNKNOWN;
 }
 
-# nagios_exit( $code, $message )
-sub nagios_exit {
+# plugin_exit( $code, $message )
+sub plugin_exit {
     my ($code, $message, $arg) = @_;
 
     # Handle named parameters
@@ -124,21 +124,21 @@ sub nagios_exit {
     $output = "$shortname $output" if $shortname;
     if ($arg->{plugin}) {
         my $plugin = $arg->{plugin};
-        $output .= " | ". $plugin->all_perfoutput 
+        $output .= " | ". $plugin->all_perfoutput
             if $plugin->perfdata && $plugin->all_perfoutput;
     }
     $output .= "\n";
 
     # Don't actually exit if _fake_exit set
     if ($_fake_exit) {
-        require Nagios::Plugin::ExitResult;
-        return Nagios::Plugin::ExitResult->new($code, $output);
+        require Monitoring::Plugin::ExitResult;
+        return Monitoring::Plugin::ExitResult->new($code, $output);
     }
 
-    _nagios_exit($code, $output);
+    _plugin_exit($code, $output);
 }
 
-sub _nagios_exit {
+sub _plugin_exit {
     my ($code, $output) = @_;
     # Print output and exit; die if flag set and called via a die in stack backtrace
     if ($_use_die) {
@@ -155,34 +155,34 @@ sub _nagios_exit {
     exit $code;
 }
 
-# nagios_die( $message, [ $code ])   OR   nagios_die( $code, $message )
+# plugin_die( $message, [ $code ])   OR   plugin_die( $code, $message )
 # Default $code: UNKNOWN
-sub nagios_die {
+sub plugin_die {
     my ($arg1, $arg2, $rest) = @_;
 
     # Named parameters
     if (defined $arg1 && ($arg1 eq 'return_code' || $arg1 eq 'message')) {
-        return nagios_exit(@_);
+        return plugin_exit(@_);
     }
 
     # ($code, $message)
     elsif (defined $arg1 && (exists $ERRORS{$arg1} || exists $STATUS_TEXT{$arg1})) {
-        return nagios_exit(@_);
+        return plugin_exit(@_);
     }
 
     # ($message, $code)
     elsif (defined $arg2 && (exists $ERRORS{$arg2} || exists $STATUS_TEXT{$arg2})) {
-        return nagios_exit($arg2, $arg1, $rest);
+        return plugin_exit($arg2, $arg1, $rest);
     }
 
     # Else just assume $arg1 is the message and hope for the best
     else {
-        return nagios_exit( UNKNOWN, $arg1, $arg2 );
+        return plugin_exit( UNKNOWN, $arg1, $arg2 );
     }
 }
 
 # For backwards compatibility
-sub die { nagios_die(@_); }
+sub die { plugin_die(@_); }
 
 
 # ------------------------------------------------------------------------
@@ -197,9 +197,9 @@ sub convert
 }
 
 # ------------------------------------------------------------------------
-# check_messages - return a status and/or message based on a set of 
+# check_messages - return a status and/or message based on a set of
 #   message arrays.
-#   Returns a nagios status code in scalar context. 
+#   Returns a nagios status code in scalar context.
 #   Returns a code and a message in list context.
 #   The message is join($join, @array) for the relevant array for the code,
 #     or join($join_all, $message) for all arrays if $join_all is set.
@@ -222,18 +222,18 @@ sub check_messages {
     # Compose message
     my $message = '';
     if ($arg{join_all}) {
-        $message = join( $arg{join_all}, 
+        $message = join( $arg{join_all},
             map { @$_ ? join( $arg{'join'}, @$_) : () }
-                $arg{critical}, 
+                $arg{critical},
                 $arg{warning},
                 $arg{ok} ? (ref $arg{ok} ? $arg{ok} : [ $arg{ok} ]) : []
         );
     }
 
     else {
-        $message ||= join( $arg{'join'}, @{$arg{critical}} ) 
+        $message ||= join( $arg{'join'}, @{$arg{critical}} )
             if $code == CRITICAL;
-        $message ||= join( $arg{'join'}, @{$arg{warning}} )  
+        $message ||= join( $arg{'join'}, @{$arg{warning}} )
             if $code == WARNING;
         $message ||= ref $arg{ok} ? join( $arg{'join'}, @{$arg{ok}} ) : $arg{ok}
             if $arg{ok};
@@ -252,28 +252,28 @@ __END__
 
 =head1 NAME
 
-Nagios::Plugin::Functions - functions to simplify the creation of 
+Monitoring::Plugin::Functions - functions to simplify the creation of
 Nagios plugins
 
 =head1 SYNOPSIS
 
     # Constants OK, WARNING, CRITICAL, and UNKNOWN exported by default
-    use Nagios::Plugin::Functions;
+    use Monitoring::Plugin::Functions;
 
-    # nagios_exit( CODE, $message ) - exit with error code CODE,
+    # plugin_exit( CODE, $message ) - exit with error code CODE,
     # and message "PLUGIN CODE - $message"
-    nagios_exit( CRITICAL, $critical_error ) if $critical_error;
-    nagios_exit( WARNING, $warning_error )   if $warning_error;
-    nagios_exit( OK, $result );
+    plugin_exit( CRITICAL, $critical_error ) if $critical_error;
+    plugin_exit( WARNING, $warning_error )   if $warning_error;
+    plugin_exit( OK, $result );
 
-    # nagios_die( $message, [$CODE] ) - just like nagios_exit(),
+    # plugin_die( $message, [$CODE] ) - just like plugin_exit(),
     # but CODE is optional, defaulting to UNKNOWN
     do_something()
-      or nagios_die("do_something() failed horribly");
+      or plugin_die("do_something() failed horribly");
     do_something_critical()
-      or nagios_die("do_something_critical() failed", CRITICAL);
+      or plugin_die("do_something_critical() failed", CRITICAL);
 
-    # check_messages - check a set of message arrays, returning a 
+    # check_messages - check a set of message arrays, returning a
     # CODE and/or a result message
     $code = check_messages(critical => \@crit, warning => \@warn);
     ($code, $message) = check_messages(
@@ -281,18 +281,18 @@ Nagios plugins
       ok => \@ok );
 
     # get_shortname - return the default short name for this plugin
-    #   (as used by nagios_exit/die; not exported by default)
+    #   (as used by plugin_exit/die; not exported by default)
     $shortname = get_shortname();
 
 
 =head1 DESCRIPTION
 
-This module is part of the Nagios::Plugin family, a set of modules
+This module is part of the Monitoring::Plugin family, a set of modules
 for simplifying the creation of Nagios plugins. This module exports
-convenience functions for the class methods provided by 
-Nagios::Plugin. It is intended for those who prefer a simpler 
-functional interface, and who do not need the additional 
-functionality of Nagios::Plugin.
+convenience functions for the class methods provided by
+Monitoring::Plugin. It is intended for those who prefer a simpler
+functional interface, and who do not need the additional
+functionality of Monitoring::Plugin.
 
 =head2 EXPORTS
 
@@ -306,8 +306,8 @@ Nagios status code constants are exported by default:
 
 as are the following functions:
 
-    nagios_exit
-    nagios_die
+    plugin_exit
+    plugin_die
     check_messages
 
 The following variables and functions are exported only on request:
@@ -325,14 +325,14 @@ The following functions are supported:
 
 =over 4
 
-=item nagios_exit( <CODE>, $message )
+=item plugin_exit( <CODE>, $message )
 
 Exit with return code CODE, and a standard nagios message of the
 form "PLUGIN CODE - $message".
 
-=item nagios_die( $message, [CODE] )
+=item plugin_die( $message, [CODE] )
 
-Same as nagios_exit(), except that CODE is optional, defaulting
+Same as plugin_exit(), except that CODE is optional, defaulting
 to UNKNOWN.  NOTE: exceptions are not raised by default to calling code.
 Set C<$_use_die> flag if this functionality is required (see test code).
 
@@ -354,7 +354,7 @@ check_messages() accepts the following named arguments:
 
 =item critical => ARRAYREF
 
-An arrayref of critical error messages - check_messages() returns 
+An arrayref of critical error messages - check_messages() returns
 CRITICAL if this arrayref is non-empty. Mandatory.
 
 =item warning => ARRAYREF
@@ -371,7 +371,7 @@ are empty. Optional.
 
 =item join => SCALAR
 
-A string used to join the relevant array to generate the message 
+A string used to join the relevant array to generate the message
 string returned in list context i.e. if the 'critical' array @crit
 is non-empty, check_messages would return:
 
@@ -383,9 +383,9 @@ as the result message. Optional; default: ' ' (space).
 
 By default, only one set of messages are joined and returned in the
 result message i.e. if the result is CRITICAL, only the 'critical'
-messages are included in the result; if WARNING, only the 'warning' 
+messages are included in the result; if WARNING, only the 'warning'
 messages are included; if OK, the 'ok' messages are included (if
-supplied) i.e. the default is to return an 'errors-only' type 
+supplied) i.e. the default is to return an 'errors-only' type
 message.
 
 If join_all is supplied, however, it will be used as a string to
@@ -397,9 +397,9 @@ all messages are joined and returned.
 =item get_shortname
 
 Return the default shortname used for this plugin i.e. the first
-token reported by nagios_exit/nagios_die. The default is basically
+token reported by plugin_exit/plugin_die. The default is basically
 
-    uc basename( $ENV{NAGIOS_PLUGIN} || $0 )
+    uc basename( $ENV{PLUGIN_NAME} || $ENV{NAGIOS_PLUGIN} || $0 )
 
 with any leading 'CHECK_' and trailing file suffixes removed.
 
@@ -427,18 +427,17 @@ internal tests performed can return UNKNOWN.
 
 =head1 SEE ALSO
 
-Nagios::Plugin; the nagios plugin developer guidelines at
-http://nagiosplug.sourceforge.net/developer-guidelines.html.
+Monitoring::Plugin; the nagios plugin developer guidelines at
+https://www.monitoring-plugins.org/doc/guidelines.html.
 
+=head1 AUTHOR
 
-=head1 AUTHORS
-
-This code is maintained by the Nagios Plugin Development Team: http://nagiosplug.sourceforge.net
-
+This code is maintained by the Monitoring Plugin Development Team: see
+https://monitoring-plugins.org
 
 =head1 COPYRIGHT AND LICENSE
 
-Copyright (C) 2006 by Nagios Plugin Development Team
+Copyright (C) 2006-2014 Monitoring Plugin Development Team
 
 This library is free software; you can redistribute it and/or modify
 it under the same terms as Perl itself.
diff --git a/lib/Nagios/Plugin/Getopt.pm b/lib/Monitoring/Plugin/Getopt.pm
index 22ff642..ce1c0f9 100644
--- a/lib/Nagios/Plugin/Getopt.pm
+++ b/lib/Monitoring/Plugin/Getopt.pm
@@ -1,9 +1,9 @@
 #
-# Nagios::Plugin::Getopt - OO perl module providing standardised argument 
+# Monitoring::Plugin::Getopt - OO perl module providing standardised argument
 #   processing for nagios plugins
 #
 
-package Nagios::Plugin::Getopt;
+package Monitoring::Plugin::Getopt;
 
 use strict;
 use File::Basename;
@@ -12,18 +12,18 @@ use Carp;
 use Params::Validate qw(:all);
 use base qw(Class::Accessor);
 
-use Nagios::Plugin::Functions;
-use Nagios::Plugin::Config;
+use Monitoring::Plugin::Functions;
+use Monitoring::Plugin::Config;
 use vars qw($VERSION);
-$VERSION = $Nagios::Plugin::Functions::VERSION;
+$VERSION = $Monitoring::Plugin::Functions::VERSION;
 
 # Standard defaults
 my %DEFAULT = (
   timeout => 15,
   verbose => 0,
   license =>
-"This nagios plugin is free software, and comes with ABSOLUTELY NO WARRANTY. 
-It may be used, redistributed and/or modified under the terms of the GNU 
+"This nagios plugin is free software, and comes with ABSOLUTELY NO WARRANTY.
+It may be used, redistributed and/or modified under the terms of the GNU
 General Public Licence (see http://www.fsf.org/licensing/licenses/gpl.txt).",
 );
 # Standard arguments
@@ -60,7 +60,7 @@ sub _die
   my $self = shift;
   my ($msg) = @_;
   $msg .= "\n" unless substr($msg, -1) eq "\n";
-  Nagios::Plugin::Functions::_nagios_exit(3, $msg);
+  Monitoring::Plugin::Functions::_plugin_exit(3, $msg);
 }
 
 # Return the given attribute, if set, including a final newline
@@ -182,7 +182,7 @@ sub _help
 }
 
 # Return a Getopt::Long-compatible option array from the current set of specs
-sub _process_specs_getopt_long 
+sub _process_specs_getopt_long
 {
   my $self = shift;
 
@@ -217,7 +217,7 @@ sub _check_required_opts
     }
   }
   if (@missing) {
-    $self->_die($self->_usage . "\n" . 
+    $self->_die($self->_usage . "\n" .
         join("\n", map { sprintf "Missing argument: %s", $_ } @missing) . "\n");
   }
 }
@@ -243,7 +243,7 @@ sub _load_config_section
   $section ||= $self->{_attr}->{plugin};
 
   my $Config;
-  eval { $Config = Nagios::Plugin::Config->read($file); };
+  eval { $Config = Monitoring::Plugin::Config->read($file); };
   $self->_die($@) if ($@); #TODO: add test?
 
   # TODO: is this check sane? Does --extra-opts=foo require a [foo] section?
@@ -295,7 +295,7 @@ sub _cmdline
     next if $key =~ m/^_/;
 
     # Skip defaults and internals
-    next if exists $DEFAULT{$key} && $hash->{$key} eq $DEFAULT{$key}; 
+    next if exists $DEFAULT{$key} && $hash->{$key} eq $DEFAULT{$key};
     next if grep { $key eq $_ } qw(help usage version extra-opts);
     next unless defined $hash->{$key};
 
@@ -307,7 +307,7 @@ sub _cmdline
         $value = $self->_cmdline_value($value);
         if (length($key) > 1) {
           push @args, sprintf "--%s=%s", $key, $value;
-        } 
+        }
         else {
           push @args, "-$key", $value;
         }
@@ -445,7 +445,7 @@ sub _init
   my $self = shift;
 
   # Check params
-  my $plugin = basename($ENV{NAGIOS_PLUGIN} || $0);
+  my $plugin = basename($ENV{PLUGIN_NAME} || $ENV{NAGIOS_PLUGIN} || $0);
   my %attr = validate( @_, {
     usage => 1,
     version => 0,
@@ -470,7 +470,7 @@ sub _init
   $self
 }
 
-sub new 
+sub new
 {
   my $class = shift;
   my $self = bless {}, $class;
@@ -485,20 +485,20 @@ __END__
 
 =head1 NAME
 
-Nagios::Plugin::Getopt - OO perl module providing standardised argument 
+Monitoring::Plugin::Getopt - OO perl module providing standardised argument
 processing for Nagios plugins
 
 
 =head1 SYNOPSIS
 
-  use Nagios::Plugin::Getopt;
+  use Monitoring::Plugin::Getopt;
 
   # Instantiate object (usage is mandatory)
-  $ng = Nagios::Plugin::Getopt->new(
+  $ng = Monitoring::Plugin::Getopt->new(
     usage => "Usage: %s -H <host> -w <warning> -c <critical>",
     version => '0.1',
     url => 'http://www.openfusion.com.au/labs/nagios/',
-    blurb => 'This plugin tests various stuff.', 
+    blurb => 'This plugin tests various stuff.',
   );
 
   # Add argument - named parameters (spec and help are mandatory)
@@ -509,7 +509,7 @@ processing for Nagios plugins
     default => 10,
   );
 
-  # Add argument - positional parameters - arg spec, help text, 
+  # Add argument - positional parameters - arg spec, help text,
   #   default value, required? (first two mandatory)
   $ng->arg(
     'warning|w=i',
@@ -528,23 +528,23 @@ processing for Nagios plugins
 
 =head1 DESCRIPTION
 
-Nagios::Plugin::Getopt is an OO perl module providing standardised and 
-simplified argument processing for Nagios plugins. It implements 
-a number of standard arguments itself (--help, --version, 
---usage, --timeout, --verbose, and their short form counterparts), 
-produces standardised nagios plugin help output, and allows 
+Monitoring::Plugin::Getopt is an OO perl module providing standardised and
+simplified argument processing for Nagios plugins. It implements
+a number of standard arguments itself (--help, --version,
+--usage, --timeout, --verbose, and their short form counterparts),
+produces standardised nagios plugin help output, and allows
 additional arguments to be easily defined.
 
 
 =head2 CONSTRUCTOR
 
   # Instantiate object (usage is mandatory)
-  $ng = Nagios::Plugin::Getopt->new(
+  $ng = Monitoring::Plugin::Getopt->new(
     usage => 'Usage: %s --hello',
     version => '0.01',
   );
 
-The Nagios::Plugin::Getopt constructor accepts the following named 
+The Monitoring::Plugin::Getopt constructor accepts the following named
 arguments:
 
 =over 4
@@ -573,7 +573,7 @@ the longer --help output. e.g.
 
 =item url
 
-URL for info about this plugin, included in the --version/-V output, 
+URL for info about this plugin, included in the --version/-V output,
 and in the longer --help output (see preceding 'version' example).
 
 =item blurb
@@ -583,20 +583,20 @@ Short plugin description, included in the longer --help output
 
 =item license
 
-License text, included in the longer --help output (see below for an 
+License text, included in the longer --help output (see below for an
 example). By default, this is set to the standard nagios plugins
 GPL license text:
 
-  This nagios plugin is free software, and comes with ABSOLUTELY 
-  NO WARRANTY. It may be used, redistributed and/or modified under 
-  the terms of the GNU General Public Licence (see 
+  This nagios plugin is free software, and comes with ABSOLUTELY
+  NO WARRANTY. It may be used, redistributed and/or modified under
+  the terms of the GNU General Public Licence (see
   http://www.fsf.org/licensing/licenses/gpl.txt).
 
 Provide your own to replace this text in the help output.
 
 =item extra
 
-Extra text to be appended at the end of the longer --help output. 
+Extra text to be appended at the end of the longer --help output.
 
 =item plugin
 
@@ -605,7 +605,7 @@ usually correct, but you can set it explicitly if not.
 
 =item timeout
 
-Timeout period in seconds, overriding the standard timeout default 
+Timeout period in seconds, overriding the standard timeout default
 (15 seconds).
 
 =back
@@ -630,8 +630,8 @@ example:
   $ ./check_tcp_range -h
   check_tcp_range 0.2 [http://www.openfusion.com.au/labs/nagios/]
 
-  This nagios plugin is free software, and comes with ABSOLUTELY NO WARRANTY. 
-  It may be used, redistributed and/or modified under the terms of the GNU 
+  This nagios plugin is free software, and comes with ABSOLUTELY NO WARRANTY.
+  It may be used, redistributed and/or modified under the terms of the GNU
   General Public Licence (see http://www.fsf.org/licensing/licenses/gpl.txt).
 
   This plugin tests arbitrary ranges/sets of tcp ports for a host.
@@ -647,7 +647,7 @@ example:
      Host name or IP address
    -p, --ports=STRING
      Port numbers to check. Format: comma-separated, colons for ranges,
-     no spaces e.g. 8700:8705,8710:8715,8760 
+     no spaces e.g. 8700:8705,8710:8715,8760
    -t, --timeout=INTEGER
      Seconds before plugin times out (default: 15)
    -v, --verbose
@@ -656,14 +656,14 @@ example:
 
 =head2 ARGUMENTS
 
-You can define arguments for your plugin using the arg() method, which 
+You can define arguments for your plugin using the arg() method, which
 supports both named and positional arguments. In both cases
-the C<spec> and C<help> arguments are required, while the C<label>, 
+the C<spec> and C<help> arguments are required, while the C<label>,
 C<default>, and C<required> arguments are optional:
 
   # Define --hello argument (named parameters)
   $ng->arg(
-    spec => 'hello|h=s', 
+    spec => 'hello|h=s',
     help => "Hello string",
     required => 1,
   );
@@ -710,12 +710,12 @@ The help string is munged in two ways:
 
 =item
 
-First, if the help string does NOT begins with a '-' sign, it is prefixed 
-by an expanded form of the C<spec> argument. For instance, the following 
+First, if the help string does NOT begins with a '-' sign, it is prefixed
+by an expanded form of the C<spec> argument. For instance, the following
 hello argument:
 
   $ng->arg(
-    spec => 'hello|h=s', 
+    spec => 'hello|h=s',
     help => "Hello string",
   );
 
@@ -727,9 +727,9 @@ would be displayed in the help output as:
 where the '-h, --hello=STRING' part is derived from the spec definition
 (by convention with short args first, then long, then label/type, if any).
 
-=item 
+=item
 
-Second, if the string contains a '%s' it will be formatted via 
+Second, if the string contains a '%s' it will be formatted via
 C<sprintf> with the 'default' as the argument i.e.
 
   sprintf($help, $default)
@@ -756,18 +756,18 @@ would be displayed in the help output as:
     Exit with WARNING status if less than PERCENT of disk space is free
 
 Note that in this case we've also specified explicit labels in another
-arrayref corresponding to the C<help> one - if this had been omitted 
-the types would have defaulted to 'STRING', instead of 'BYTES' and 
+arrayref corresponding to the C<help> one - if this had been omitted
+the types would have defaulted to 'STRING', instead of 'BYTES' and
 'PERCENT%'.
 
 
 =item label
 
-The C<label> argument is a scalar or an arrayref (see 'Multi-line help' 
+The C<label> argument is a scalar or an arrayref (see 'Multi-line help'
 description above) that overrides the standard type expansion when generating
-help text from the spec definition. By default, C<spec=i> arguments are 
-labelled as C<=INTEGER> in the help text, and C<spec=s> arguments are labelled 
-as C<=STRING>. By supplying your own C<label> argument you can override these 
+help text from the spec definition. By default, C<spec=i> arguments are
+labelled as C<=INTEGER> in the help text, and C<spec=s> arguments are labelled
+as C<=STRING>. By supplying your own C<label> argument you can override these
 standard 'INTEGER' and 'STRING' designations.
 
 For multi-line help, you can supply an ordered list (arrayref) of labels to
@@ -789,13 +789,13 @@ if none is explicitly supplied.
 
 =item required
 
-The C<required> argument is a boolean used to indicate that this argument 
-is mandatory (Nagios::Plugin::Getopt will exit with your usage message and 
+The C<required> argument is a boolean used to indicate that this argument
+is mandatory (Monitoring::Plugin::Getopt will exit with your usage message and
 a 'Missing argument' indicator if any required arguments are not supplied).
 
 =back
 
-Note that --help lists your arguments in the order they are defined, so 
+Note that --help lists your arguments in the order they are defined, so
 you should order your C<arg()> calls accordingly.
 
 
@@ -809,7 +809,7 @@ method, which takes no arguments:
 
 This parses the command line arguments passed to your plugin using
 Getopt::Long and the builtin and provided argument specifications.
-Flags and argument values are recorded within the object, and can 
+Flags and argument values are recorded within the object, and can
 be accessed either using the generic get() accessor, or using named
 accessors corresponding to your argument names. For example:
 
@@ -824,14 +824,14 @@ accessors corresponding to your argument names. For example:
     # ...
   }
 
-Note that where you have defined alternate argument names, the first is 
-considered the citation form. All the builtin arguments are available 
+Note that where you have defined alternate argument names, the first is
+considered the citation form. All the builtin arguments are available
 using their long variant names.
 
 
 =head2 BUILTIN PROCESSING
 
-The C<getopts()> method also handles processing of the immediate builtin 
+The C<getopts()> method also handles processing of the immediate builtin
 arguments, namely --usage, --version, --help, as well as checking all
 required arguments have been supplied, so you don't have to handle
 those yourself. This means that your plugin will exit from the getopts()
@@ -842,32 +842,28 @@ C<getopts()> also sets up a default ALRM timeout handler so you can use an
 
   alarm $ng->timeout;
 
-around any blocking operations within your plugin (which you are free 
+around any blocking operations within your plugin (which you are free
 to override if you want to use a custom timeout message).
 
 
 =head1 SEE ALSO
 
-Nagios::Plugin, Getopt::Long
+Monitoring::Plugin, Getopt::Long
 
 
 =head1 AUTHOR
 
-Gavin Carr <gavin@openfusion.com.au>
+This code is maintained by the Monitoring Plugin Development Team: see
+https://monitoring-plugins.org
 
+Originally:
+  Gavin Carr <gavin@openfusion.com.au>
 
 =head1 COPYRIGHT AND LICENSE
 
-Copyright (C) 2006-2007 by the Nagios Plugin Development Team.
+Copyright (C) 2006-2014 Monitoring Plugin Development Team
 
-This module is free software. It may be used, redistributed
-and/or modified under either the terms of the Perl Artistic 
-License (see http://www.perl.com/perl/misc/Artistic.html)
-or the GNU General Public Licence (see 
-http://www.fsf.org/licensing/licenses/gpl.txt).
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself.
 
 =cut
-
-# arch-tag: c917effc-7400-4ee5-a5d6-baa9316a3abf
-# vim:smartindent:sw=2:et
-
diff --git a/lib/Nagios/Plugin/Performance.pm b/lib/Monitoring/Plugin/Performance.pm
index 9248fea..90fc9f4 100644
--- a/lib/Nagios/Plugin/Performance.pm
+++ b/lib/Monitoring/Plugin/Performance.pm
@@ -1,4 +1,4 @@
-package Nagios::Plugin::Performance;
+package Monitoring::Plugin::Performance;
 
 use 5.006;
 
@@ -11,15 +11,15 @@ __PACKAGE__->mk_ro_accessors(
     qw(label value uom warning critical min max)
 );
 
-use Nagios::Plugin::Functions;
-use Nagios::Plugin::Threshold;
-use Nagios::Plugin::Range;
-our ($VERSION) = $Nagios::Plugin::Functions::VERSION;
+use Monitoring::Plugin::Functions;
+use Monitoring::Plugin::Threshold;
+use Monitoring::Plugin::Range;
+our ($VERSION) = $Monitoring::Plugin::Functions::VERSION;
 
 sub import {
         my ($class, %attr) = @_;
         $_ = $attr{use_die} || 0;
-        Nagios::Plugin::Functions::_use_die($_);
+        Monitoring::Plugin::Functions::_use_die($_);
 }
 
 # This is NOT the same as N::P::Functions::value_re. We leave that to be the strict
@@ -46,7 +46,7 @@ sub _parse {
                 return undef if $not_value;
         }
     my $p = $class->new(
-        label => $info[0], value => $performance_value, uom => $info[2], warning => $info[3], critical => $info[4], 
+        label => $info[0], value => $performance_value, uom => $info[2], warning => $info[3], critical => $info[4],
         min => $info[5], max => $info[6]
     );
         return $p;
@@ -128,13 +128,13 @@ sub clean_label {
 sub threshold
 {
     my $self = shift;
-    return Nagios::Plugin::Threshold->set_thresholds(
+    return Monitoring::Plugin::Threshold->set_thresholds(
         warning => $self->warning, critical => $self->critical
     );
 }
 
 # Constructor - unpack thresholds, map args to hashref
-sub new 
+sub new
 {
     my $class = shift;
     my %arg = @_;
@@ -154,15 +154,15 @@ __END__
 
 =head1 NAME
 
-Nagios::Plugin::Performance - class for handling Nagios::Plugin
+Monitoring::Plugin::Performance - class for handling Monitoring::Plugin
 performance data.
 
 =head1 SYNOPSIS
 
-  use Nagios::Plugin::Performance use_die => 1;
+  use Monitoring::Plugin::Performance use_die => 1;
 
   # Constructor (also accepts a 'threshold' obj instead of warning/critical)
-  $p = Nagios::Plugin::Performance->new(
+  $p = Monitoring::Plugin::Performance->new(
       label     => 'size',
       value     => $value,
       uom       => "kB",
@@ -173,9 +173,9 @@ performance data.
   );
 
   # Parser
-  @perf = Nagios::Plugin::Performance->parse_perfstring(
+  @perf = Monitoring::Plugin::Performance->parse_perfstring(
       "/=382MB;15264;15269;; /var=218MB;9443;9448"
-  ) 
+  )
   or warn("Failed to parse perfstring");
 
   # Accessors
@@ -197,14 +197,14 @@ performance data.
 
 =head1 DESCRIPTION
 
-Nagios::Plugin class for handling performance data. This is a public 
-interface because it could be used by performance graphing routines, 
-such as nagiostat (http://nagiostat.sourceforge.net), perfparse 
-(http://perfparse.sourceforge.net), nagiosgraph 
-(http://nagiosgraph.sourceforge.net) or NagiosGrapher 
+Monitoring::Plugin class for handling performance data. This is a public
+interface because it could be used by performance graphing routines,
+such as nagiostat (http://nagiostat.sourceforge.net), perfparse
+(http://perfparse.sourceforge.net), nagiosgraph
+(http://nagiosgraph.sourceforge.net) or NagiosGrapher
 (http://www.nagiosexchange.org/NagiosGrapher.84.0.html).
 
-Nagios::Plugin::Performance offers both a parsing interface (via 
+Monitoring::Plugin::Performance offers both a parsing interface (via
 parse_perfstring), for turning nagios performance output strings into
 their components, and a composition interface (via new), for turning
 components into perfdata strings.
@@ -213,7 +213,7 @@ components into perfdata strings.
 
 If you are using this module for the purposes of parsing perf data, you
 will probably want to set use_die => 1 at use time. This forces
-&Nagios::Plugin::Functions::nagios_exit to call die() - rather than exit() -
+&Monitoring::Plugin::Functions::plugin_exit to call die() - rather than exit() -
 when an error occurs. This is then trappable by an eval. If you don't set use_die,
 then an error in these modules will cause your script to exit
 
@@ -221,14 +221,14 @@ then an error in these modules will cause your script to exit
 
 =over 4
 
-=item Nagios::Plugin::Performance->new(%attributes)
+=item Monitoring::Plugin::Performance->new(%attributes)
 
-Instantiates a new Nagios::Plugin::Performance object with the given 
+Instantiates a new Monitoring::Plugin::Performance object with the given
 attributes.
 
-=item Nagios::Plugin::Performance->parse_perfstring($string)
+=item Monitoring::Plugin::Performance->parse_perfstring($string)
 
-Returns an array of Nagios::Plugin::Performance objects based on the string 
+Returns an array of Monitoring::Plugin::Performance objects based on the string
 entered. If there is an error parsing the string - which may consists of several
 sets of data -  will return an array with all the successfully parsed sets.
 
@@ -247,18 +247,18 @@ These all return scalars. min and max are not well supported yet.
 
 =item threshold
 
-Returns a Nagios::Plugin::Threshold object holding the warning and critical 
+Returns a Monitoring::Plugin::Threshold object holding the warning and critical
 ranges for this performance data (if any).
 
 =item rrdlabel
 
-Returns a string based on 'label' that is suitable for use as dataset name of 
-an RRD i.e. munges label to be 1-19 characters long with only characters 
+Returns a string based on 'label' that is suitable for use as dataset name of
+an RRD i.e. munges label to be 1-19 characters long with only characters
 [a-zA-Z0-9_].
 
 This calls $self->clean_label and then truncates to 19 characters.
 
-There is no guarantee that multiple N:P:Performance objects will have unique 
+There is no guarantee that multiple N:P:Performance objects will have unique
 rrdlabels.
 
 =item clean_label
@@ -270,25 +270,25 @@ It also converts "/" to "root" and "/{name}" to "{name}".
 
 =item perfoutput
 
-Outputs the data in Nagios::Plugin perfdata format i.e. 
+Outputs the data in Monitoring::Plugin perfdata format i.e.
 label=value[uom];[warn];[crit];[min];[max].
 
-=back 
+=back
 
 =head1 SEE ALSO
 
-Nagios::Plugin, Nagios::Plugin::Threshold, http://nagiosplug.sourceforge.net.
+Monitoring::Plugin, Monitoring::Plugin::Threshold, https://www.monitoring-plugins.org/doc/guidelines.html
 
 =head1 AUTHOR
 
-This code is maintained by the Nagios Plugin Development Team: see
-http://nagiosplug.sourceforge.net.
+This code is maintained by the Monitoring Plugin Development Team: see
+https://monitoring-plugins.org
 
 =head1 COPYRIGHT AND LICENSE
 
-Copyright (C) 2006-2007 Nagios Plugin Development Team
+Copyright (C) 2006-2014 Monitoring Plugin Development Team
 
 This library is free software; you can redistribute it and/or modify
-it under the same terms as Perl itself. 
+it under the same terms as Perl itself.
 
 =cut
diff --git a/lib/Nagios/Plugin/Range.pm b/lib/Monitoring/Plugin/Range.pm
index 536f6bb..af19577 100644
--- a/lib/Nagios/Plugin/Range.pm
+++ b/lib/Monitoring/Plugin/Range.pm
@@ -1,4 +1,4 @@
-package Nagios::Plugin::Range;
+package Monitoring::Plugin::Range;
 
 use 5.006;
 
@@ -11,8 +11,8 @@ __PACKAGE__->mk_accessors(
     qw(start end start_infinity end_infinity alert_on)
 );
 
-use Nagios::Plugin::Functions qw(:DEFAULT $value_re);
-our ($VERSION) = $Nagios::Plugin::Functions::VERSION;
+use Monitoring::Plugin::Functions qw(:DEFAULT $value_re);
+our ($VERSION) = $Monitoring::Plugin::Functions::VERSION;
 
 use overload
         'eq' => sub { shift->_stringify },
@@ -26,7 +26,7 @@ sub _stringify {
         my $self = shift;
         return "" unless $self->is_set;
         return (($self->alert_on) ? "@" : "") .
-                (($self->start_infinity == 1) ? "~:" : (($self->start == 0)?"":$self->start.":")) . 
+                (($self->start_infinity == 1) ? "~:" : (($self->start == 0)?"":$self->start.":")) .
                 (($self->end_infinity == 1) ? "" : $self->end);
 }
 
@@ -47,7 +47,7 @@ sub _set_range_end {
         $self->end_infinity(0);
 }
 
-# Returns a N::P::Range object if the string is a conforms to a Nagios Plugin range string, otherwise null
+# Returns a N::P::Range object if the string is a conforms to a Monitoring Plugin range string, otherwise null
 sub parse_range_string {
         my ($class, $string) = @_;
         my $valid = 0;
@@ -118,7 +118,7 @@ sub check_range {
 }
 
 # Constructor - map args to hashref for SUPER
-sub new 
+sub new
 {
     shift->SUPER::new({ @_ });
 }
@@ -129,18 +129,18 @@ __END__
 
 =head1 NAME
 
-Nagios::Plugin::Range - class for handling Nagios::Plugin range data.
+Monitoring::Plugin::Range - class for handling Monitoring::Plugin range data.
 
 =head1 SYNOPSIS
 
-    # NB: This is an internal Nagios::Plugin class. 
-    # See Nagios::Plugin itself for public interfaces.
+    # NB: This is an internal Monitoring::Plugin class.
+    # See Monitoring::Plugin itself for public interfaces.
 
     # Instantiate an empty range object
-    $r = Nagios::Plugin::Range->new; 
+    $r = Monitoring::Plugin::Range->new;
 
     # Instantiate by parsing a standard nagios range string
-    $r = Nagios::Plugin::Range->parse_range_string( $range_str );
+    $r = Monitoring::Plugin::Range->parse_range_string( $range_str );
 
     # Returns true if the range is defined/non-empty
     $r->is_set;
@@ -151,17 +151,17 @@ Nagios::Plugin::Range - class for handling Nagios::Plugin range data.
 
 =head1 DESCRIPTION
 
-Internal Nagios::Plugin class for handling common range data. See 
-Nagios::Plugin for public interfaces.
+Internal Monitoring::Plugin class for handling common range data. See
+Monitoring::Plugin for public interfaces.
 
 =head1 AUTHOR
 
-This code is maintained by the Nagios Plugin Development Team: see
-http://nagiosplug.sourceforge.net.
+This code is maintained by the Monitoring Plugin Development Team: see
+https://monitoring-plugins.org
 
 =head1 COPYRIGHT AND LICENSE
 
-Copyright (C) 2006-2007 Nagios Plugin Development Team
+Copyright (C) 2006-2014 Monitoring Plugin Development Team
 
 This library is free software; you can redistribute it and/or modify
 it under the same terms as Perl itself.
diff --git a/lib/Nagios/Plugin/Threshold.pm b/lib/Monitoring/Plugin/Threshold.pm
index 95a089b..e71e21b 100644
--- a/lib/Nagios/Plugin/Threshold.pm
+++ b/lib/Monitoring/Plugin/Threshold.pm
@@ -1,4 +1,4 @@
-package Nagios::Plugin::Threshold;
+package Monitoring::Plugin::Threshold;
 
 use 5.006;
 
@@ -8,11 +8,11 @@ use warnings;
 use base qw(Class::Accessor::Fast);
 __PACKAGE__->mk_accessors(qw(warning critical));
 
-use Nagios::Plugin::Range;
-use Nagios::Plugin::Functions qw(:codes nagios_die);
-our ($VERSION) = $Nagios::Plugin::Functions::VERSION;
+use Monitoring::Plugin::Range;
+use Monitoring::Plugin::Functions qw(:codes plugin_die);
+our ($VERSION) = $Monitoring::Plugin::Functions::VERSION;
 
-sub get_status 
+sub get_status
 {
         my ($self, $value) = @_;
 
@@ -22,7 +22,7 @@ sub get_status
                         return CRITICAL if $self->critical->check_range($v);
                 }
         }
-        foreach my $v (@$value) { 
+        foreach my $v (@$value) {
                 if ($self->warning->is_set) {
                         return WARNING if $self->warning->check_range($v);
                 }
@@ -35,21 +35,21 @@ sub _inflate
     my ($self, $value, $key) = @_;
 
     # Return an undefined range if $value is undef
-    return Nagios::Plugin::Range->new if ! defined $value;
+    return Monitoring::Plugin::Range->new if ! defined $value;
 
     # For refs, check isa N::P::Range
     if (ref $value) {
-        nagios_die("Invalid $key object: type " . ref $value)
-            unless $value->isa("Nagios::Plugin::Range");
+        plugin_die("Invalid $key object: type " . ref $value)
+            unless $value->isa("Monitoring::Plugin::Range");
         return $value;
     }
 
     # Another quick exit if $value is an empty string
-    return Nagios::Plugin::Range->new if $value eq "";
+    return Monitoring::Plugin::Range->new if $value eq "";
 
     # Otherwise parse $value
-    my $range = Nagios::Plugin::Range->parse_range_string($value);
-    nagios_die("Cannot parse $key range: '$value'") unless(defined($range));
+    my $range = Monitoring::Plugin::Range->parse_range_string($value);
+    plugin_die("Cannot parse $key range: '$value'") unless(defined($range));
     return $range;
 }
 
@@ -70,9 +70,9 @@ sub set
     my ($key, $value) = @_;
     $self->SUPER::set($key, $self->_inflate($value, $key));
 }
-                
+
 # Constructor - inflate scalars to N::P::Range objects
-sub new 
+sub new
 {
     my ($self, %arg) = @_;
     $self->SUPER::new({
@@ -86,15 +86,15 @@ __END__
 
 =head1 NAME
 
-Nagios::Plugin::Threshold - class for handling Nagios::Plugin thresholds.
+Monitoring::Plugin::Threshold - class for handling Monitoring::Plugin thresholds.
 
 =head1 SYNOPSIS
 
-    # NB: This is an internal Nagios::Plugin class.
-    # See Nagios::Plugin itself for public interfaces.
-  
+    # NB: This is an internal Monitoring::Plugin class.
+    # See Monitoring::Plugin itself for public interfaces.
+
     # Constructor
-    $t = Nagios::Plugin::Threshold->set_thresholds(
+    $t = Monitoring::Plugin::Threshold->set_thresholds(
         warning  => $warning_range_string,
         critical => $critical_range_string,
     );
@@ -110,10 +110,10 @@ Nagios::Plugin::Threshold - class for handling Nagios::Plugin thresholds.
 
 =head1 DESCRIPTION
 
-Internal Nagios::Plugin class for handling threshold data. See 
-Nagios::Plugin for public interfaces.
+Internal Monitoring::Plugin class for handling threshold data. See
+Monitoring::Plugin for public interfaces.
 
-A threshold object contains (typically) a pair of ranges, associated 
+A threshold object contains (typically) a pair of ranges, associated
 with a particular severity e.g.
 
   warning  => range1
@@ -121,12 +121,12 @@ with a particular severity e.g.
 
 =head1 AUTHOR
 
-This code is maintained by the Nagios Plugin Development Team: see
-http://nagiosplug.sourceforge.net.
+This code is maintained by the Monitoring Plugin Development Team: see
+https://monitoring-plugins.org
 
 =head1 COPYRIGHT AND LICENSE
 
-Copyright (C) 2006-2007 Nagios Plugin Development Team
+Copyright (C) 2006-2014 Monitoring Plugin Development Team
 
 This library is free software; you can redistribute it and/or modify
 it under the same terms as Perl itself.
diff --git a/lib/Nagios/Plugin/ExitResult.pm b/lib/Nagios/Plugin/ExitResult.pm
deleted file mode 100644
index b161e9e..0000000
--- a/lib/Nagios/Plugin/ExitResult.pm
+++ /dev/null
@@ -1,67 +0,0 @@
-# Tiny helper class to return both output and return_code when testing
-
-package Nagios::Plugin::ExitResult;
-
-use strict;
-
-# Stringify to message
-use overload '""' => sub { shift->{message} };
-
-# Constructor
-sub new { 
-    my $class = shift;
-    return bless { return_code => $_[0], message => $_[1] }, $class;
-}
-
-# Accessors
-sub message { shift->{message} }
-sub return_code { shift->{return_code} }
-sub code { shift->{return_code} }
-
-1;
-
-__END__
-
-=head1 NAME
-
-Nagios::Plugin::ExitResult - Helper class for returning both output and 
-return codes when testing.
-
-=head1 SYNOPSIS
-
-    use Test::More;
-    use Nagios::Plugin::Functions;
-
-    # In a test file somewhere
-    Nagios::Plugin::Functions::_fake_exit(1);
-
-    # Later ...
-    $e = nagios_exit( CRITICAL, 'aiiii ...' );
-    print $e->message;
-    print $e->return_code;
-
-    # NP::ExitResult also stringifies to the message output
-    like(nagios_exit( WARNING, 'foobar'), qr/^foo/, 'matches!');
-
-
-
-=head1 DESCRIPTION
-
-Nagios::Plugin::ExitResult is a tiny helper class intended for use 
-when testing other Nagios::Plugin modules. A Nagios::Plugin::ExitResult 
-object is returned by nagios_exit() and friends when 
-Nagios::Plugin::Functions::_fake_exit has been set, instead of doing a 
-conventional print + exit.
-
-=head1 AUTHOR
-
-Gavin Carr , E<lt>gavin@openfusion.com.auE<gt>
-
-=head1 COPYRIGHT AND LICENSE
-
-Copyright (C) 2006 by Nagios Plugin Development Team
-
-This library is free software; you can redistribute it and/or modify
-it under the same terms as Perl itself.
-
-=cut