NAME

       Sys::Statistics::Linux::Compilation - Statistics compilation.

SYNOPSIS

           use Sys::Statistics::Linux;

           my $lxs  = Sys::Statistics::Linux->new( loadavg => 1 );
           my $stat = $lxs->get;

           foreach my $key ($stat->loadavg) {
               print $key, " ", $stat->loadavg($key), "\n";
           }

           # or

           use Sys::Statistics::Linux::LoadAVG;
           use Sys::Statistics::Linux::Compilation;

           my $lxs  = Sys::Statistics::Linux::LoadAVG->new();
           my $load = $lxs->get;
           my $stat = Sys::Statistics::Linux::Compilation->new({ loadavg => $load });

           foreach my $key ($stat->loadavg) {
               print $key, " ", $stat->loadavg($key), "\n";
           }

           # or

           foreach my $key ($stat->loadavg) {
               print $key, " ", $stat->loadavg->{$key}, "\n";
           }

DESCRIPTION

       This module provides different methods to access and filter the statistics compilation.

METHODS

   new()
       Create a new "Sys::Statistics::Linux::Compilation" object. This creator is only useful if
       you don't call "get()" of "Sys::Statistics::Linux". You can create a new object with:

           my $lxs  = Sys::Statistics::Linux::LoadAVG->new();
           my $load = $lxs->get;
           my $stat = Sys::Statistics::Linux::Compilation->new({ loadavg => $load });

   Statistic methods
       sysinfo()
       cpustats()
       procstats()
       memstats()
       pgswstats()
       netstats()
       netinfo()
           "netinfo()" provides raw data - no deltas.

       sockstats()
       diskstats()
       diskusage()
       loadavg()
       filestats()
       processes()

       All methods returns the statistics as a hash reference in scalar context. In list all
       methods returns the first level keys of the statistics. Example:

           my $net  = $stat->netstats;                 # netstats as a hash reference
           my @dev  = $stat->netstats;                 # the devices eth0, eth1, ...
           my $eth0 = $stat->netstats('eth0');         # eth0 statistics as a hash reference
           my @keys = $stat->netstats('eth0');         # the statistic keys
           my @vals = $stat->netstats('eth0', @keys);  # the values for the passed device and @keys
           my $val  = $stat->netstats('eth0', $key);   # the value for the passed device and key

       Sorted ...

           my @dev  = sort $stat->netstats;
           my @keys = sort $stat->netstats('eth0');

   pstop()
       This method is looking for top processes and returns a sorted list of PIDs as an array or
       array reference depending on the context. It expected two values: a key name and the
       number of top processes to return.

       As example you want to get the top 5 processes with the highest cpu usage:

           my @top5 = $stat->pstop( ttime => 5 );
           # or as a reference
           my $top5 = $stat->pstop( ttime => 5 );

       If you want to get all processes:

           my @top_all = $stat->pstop( ttime => $FALSE );
           # or just
           my @top_all = $stat->pstop( 'ttime' );

   search(), psfind()
       Both methods provides a simple scan engine to find special statistics. Both methods except
       a filter as a hash reference. It's possible to pass the statistics as second argument if
       the data is not stored in the object.

       The method "search()" scans for statistics and rebuilds the hash tree until that keys that
       matched your filter and returns the hits as a hash reference.

           my $hits = $stat->search({
               processes => {
                   cmd   => qr/\[su\]/,
                   owner => qr/root/
               },
               cpustats => {
                   idle   => 'lt:10',
                   iowait => 'gt:10'
               },
               diskusage => {
                   '/dev/sda1' => {
                       usageper => 'gt:80'
                   }
               }
           });

       This would return the following matches:

           * processes with the command "[su]"
           * processes with the owner "root"
           * all cpu where "idle" is less than 50
           * all cpu where "iowait" is grather than 10
           * only disk '/dev/sda1' if "usageper" is grather than 80

       The method "psfind()" scans for processes only and returns a array reference with all
       process IDs that matched the filter. Example:

           my $pids = $stat->psfind({ cmd => qr/init/, owner => 'eq:apache' });

       This would return the following process ids:

           * processes that matched the command "init"
           * processes with the owner "apache"

       There are different match operators available:

           gt  -  grather than
           lt  -  less than
           eq  -  is equal
           ne  -  is not equal

       Notation examples:

           gt:50
           lt:50
           eq:50
           ne:50

       Both argumnents have to be set as a hash reference.

       Note: the operators < > = ! are not available any more. It's possible that in further
       releases could be different changes for "search()" and "psfind()". So please take a look
       to the documentation if you use it.

EXPORTS

       No exports.

TODOS

          * Are there any wishs from your side? Send me a mail!

REPORTING BUGS

       Please report all bugs to <jschulz.cpan(at)bloonix.de>.

AUTHOR

       Jonny Schulz <jschulz.cpan(at)bloonix.de>.

       Thanks to Moritz Lenz for his suggestion for the name of this module.

COPYRIGHT

       Copyright (c) 2006, 2007 by Jonny Schulz. All rights reserved.

       This program is free software; you can redistribute it and/or modify it under the same
       terms as Perl itself.