src/lib/Torrus/ReportGenerator/MonthlySrvUsage.pm

   1 #  Copyright (C) 2005  Stanislav Sinyagin
   2 #
   3 #  This program is free software; you can redistribute it and/or modify
   4 #  it under the terms of the GNU General Public License as published by
   5 #  the Free Software Foundation; either version 2 of the License, or
   6 #  (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software
  15 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  16
  17 # Stanislav Sinyagin <ssinyagin@yahoo.com>
  18
  19 # For all service IDs available, build monthly usage figures:
  20 # Average, Maximum, and Percentile (default 95th percentile)
  21 #
  22
  23 package Torrus::ReportGenerator::MonthlySrvUsage;
  24
  25 use strict;
  26 use warnings;
  27
  28 use base 'Torrus::ReportGenerator';
  29
  30 use POSIX qw(floor);
  31 use Date::Parse;
  32 use Math::BigFloat;
  33
  34 use Torrus::Log;
  35 use Torrus::ServiceID;
  36
  37
  38 our $VERSION = 1.0;
  39
  40 sub isMonthly
  41 {
  42     return 1;
  43 }
  44
  45 sub usesSrvExport
  46 {
  47     return 1;
  48 }
  49
  50
  51 sub generate
  52 {
  53     my $self = shift;
  54
  55     my $percentile = $self->{'options'}->{'Percentile'};
  56     if( not defined( $percentile ) )
  57     {
  58         $percentile = 95;
  59     }
  60
  61     my $step = $self->{'options'}->{'Step'};
  62     if( not defined( $step ) )
  63     {
  64         $step = 300;
  65     }
  66
  67     my $srvIDParams = Torrus::ServiceID->new();
  68
  69     my $srvIDs = $self->{'srvexport'}->getServiceIDs();
  70     for my $serviceid ( @{$srvIDs} )
  71     {
  72         &Torrus::DB::checkInterrupted();
  73
  74         my $data = $self->{'srvexport'}->getIntervalData
  75             ( $self->{'StartDate'}, $self->{'EndDate'}, $serviceid );
  76
  77         &Torrus::DB::checkInterrupted();
  78
  79         next if scalar( @{$data} ) == 0;
  80         Debug('MonthlySrvUsage: Generating report for ' . $serviceid);
  81
  82         my $params = $srvIDParams->getParams( $serviceid );
  83
  84         my @aligned = ();
  85         $#aligned = floor( $self->{'RangeSeconds'} / $step );
  86         my $nDatapoints = scalar( @aligned );
  87
  88         # Fill in the aligned array. For each interval by modulo(step),
  89         # we take the maximum value from the available data
  90
  91         my $maxVal = 0;
  92
  93         for my $row ( @{$data} )
  94         {
  95             my $rowtime = str2time( $row->{'srv_date'} . 'T' .
  96                                     $row->{'srv_time'} );
  97             my $pos = floor( ($rowtime - $self->{'StartUnixTime'}) / $step );
  98             my $value = Math::BigFloat->new( $row->{'value'} );
  99             if( $value->is_nan() )
 100             {
 101                 $value->bzero();
 102                 $row->{'value'} = 0;
 103             }
 104
 105             if( ( not defined( $aligned[$pos] ) ) or
 106                 $aligned[$pos] < $value )
 107             {
 108                 $aligned[$pos] = $value;
 109                 if( $value > $maxVal )
 110                 {
 111                     $maxVal = $value;
 112                 }
 113             }
 114         }
 115
 116         &Torrus::DB::checkInterrupted();
 117
 118         # Set undefined values to zero and calculate the average
 119
 120         my $sum = Math::BigFloat->new(0);
 121         my $unavailCount = 0;
 122         for my $pos ( 0 .. $#aligned )
 123         {
 124             if( not defined( $aligned[$pos] ) )
 125             {
 126                 $aligned[$pos] = 0;
 127                 $unavailCount++;
 128             }
 129             else
 130             {
 131                 $sum += $aligned[$pos];
 132             }
 133         }
 134
 135         &Torrus::DB::checkInterrupted();
 136
 137         my $avgVal = $sum / $nDatapoints;
 138
 139         # Calculate the percentile
 140
 141         my @sorted = sort {$a <=> $b} @aligned;
 142         my $pcPos = floor( $nDatapoints * $percentile / 100 );
 143         my $pcVal = $sorted[$pcPos];
 144
 145         # Calculate the total volume if it's a counter
 146         my $volume = Math::BigFloat->new(0);
 147         my $volumeDefined = 0;
 148         if( not defined( $params->{'dstype'} ) or
 149             $params->{'dstype'} =~ /^COUNTER/o )
 150         {
 151             $volumeDefined = 1;
 152             for my $row ( @{$data} )
 153             {
 154                 $volume += $row->{'value'} * $row->{'intvl'};
 155             }
 156         }
 157
 158         # Adjust units and scale
 159
 160         my $usageUnits = '';
 161         my $volumeUnits = '';
 162         if( not defined( $params->{'units'} ) or
 163             $params->{'units'} eq 'bytes' )
 164         {
 165             # Adjust bytes into megabit per second
 166             $usageUnits = 'Mbps';
 167             $maxVal *= 8e-6;
 168             $avgVal *= 8e-6;
 169             $pcVal  *= 8e-6;
 170
 171             # Adjust volume bytes into megabytes
 172             $volumeUnits = 'GB';
 173             $volume /= 1073741824;
 174         }
 175
 176         $self->{'backend'}->addField( $self->{'reportId'}, {
 177             'name'      => 'MAX',
 178             'serviceid' => $serviceid,
 179             'value'     => $maxVal,
 180             'units'     => $usageUnits });
 181
 182         $self->{'backend'}->addField( $self->{'reportId'}, {
 183             'name'      => 'AVG',
 184             'serviceid' => $serviceid,
 185             'value'     => $avgVal,
 186             'units'     => $usageUnits });
 187
 188         $self->{'backend'}->addField( $self->{'reportId'}, {
 189             'name'      => sprintf('%s%s', $percentile, 'TH_PERCENTILE'),
 190             'serviceid' => $serviceid,
 191             'value'     => $pcVal,
 192             'units'     => $usageUnits });
 193
 194         $self->{'backend'}->addField( $self->{'reportId'}, {
 195             'name'      => 'UNAVAIL',
 196             'serviceid' => $serviceid,
 197             'value'     => ($unavailCount*100)/$nDatapoints,
 198             'units'     => '%' });
 199
 200         if( $volumeDefined )
 201         {
 202             $self->{'backend'}->addField( $self->{'reportId'}, {
 203                 'name'      => 'VOLUME',
 204                 'serviceid' => $serviceid,
 205                 'value'     => $volume,
 206                 'units'     => $volumeUnits });
 207         }
 208     }
 209
 210     &Torrus::DB::checkInterrupted();
 211
 212     $self->{'backend'}->finalize( $self->{'reportId'} );
 213     return;
 214 }
 215
 216
 217
 218 1;
 219
 220
 221 # Local Variables:
 222 # mode: perl
 223 # indent-tabs-mode: nil
 224 # perl-indent-level: 4
 225 # End: