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 # $Id$
  18 # Stanislav Sinyagin <ssinyagin@yahoo.com>
  19
  20 # For all service IDs available, build monthly usage figures:
  21 # Average, Maximum, and Percentile (default 95th percentile)
  22 #
  23
  24 package Torrus::ReportGenerator::MonthlySrvUsage;
  25
  26 use strict;
  27 use warnings;
  28
  29 use base 'Torrus::ReportGenerator';
  30
  31 use POSIX qw(floor);
  32 use Date::Parse;
  33 use Math::BigFloat;
  34
  35 use Torrus::Log;
  36 use Torrus::ServiceID;
  37
  38
  39 our $VERSION = 1.0;
  40
  41 sub isMonthly
  42 {
  43     return 1;
  44 }
  45
  46 sub usesSrvExport
  47 {
  48     return 1;
  49 }
  50
  51
  52 sub generate
  53 {
  54     my $self = shift;
  55
  56     my $percentile = $self->{'options'}->{'Percentile'};
  57     if( not defined( $percentile ) )
  58     {
  59         $percentile = 95;
  60     }
  61
  62     my $step = $self->{'options'}->{'Step'};
  63     if( not defined( $step ) )
  64     {
  65         $step = 300;
  66     }
  67
  68     my $srvIDParams = Torrus::ServiceID->new();
  69
  70     my $srvIDs = $self->{'srvexport'}->getServiceIDs();
  71     for my $serviceid ( @{$srvIDs} )
  72     {
  73         &Torrus::DB::checkInterrupted();
  74
  75         my $data = $self->{'srvexport'}->getIntervalData
  76             ( $self->{'StartDate'}, $self->{'EndDate'}, $serviceid );
  77
  78         &Torrus::DB::checkInterrupted();
  79
  80         next if scalar( @{$data} ) == 0;
  81         Debug('MonthlySrvUsage: Generating report for ' . $serviceid);
  82
  83         my $params = $srvIDParams->getParams( $serviceid );
  84
  85         my @aligned = ();
  86         $#aligned = floor( $self->{'RangeSeconds'} / $step );
  87         my $nDatapoints = scalar( @aligned );
  88
  89         # Fill in the aligned array. For each interval by modulo(step),
  90         # we take the maximum value from the available data
  91
  92         my $maxVal = 0;
  93
  94         for my $row ( @{$data} )
  95         {
  96             my $rowtime = str2time( $row->{'srv_date'} . 'T' .
  97                                     $row->{'srv_time'} );
  98             my $pos = floor( ($rowtime - $self->{'StartUnixTime'}) / $step );
  99             my $value = Math::BigFloat->new( $row->{'value'} );
 100             if( $value->is_nan() )
 101             {
 102                 $value->bzero();
 103                 $row->{'value'} = 0;
 104             }
 105
 106             if( ( not defined( $aligned[$pos] ) ) or
 107                 $aligned[$pos] < $value )
 108             {
 109                 $aligned[$pos] = $value;
 110                 if( $value > $maxVal )
 111                 {
 112                     $maxVal = $value;
 113                 }
 114             }
 115         }
 116
 117         &Torrus::DB::checkInterrupted();
 118
 119         # Set undefined values to zero and calculate the average
 120
 121         my $sum = Math::BigFloat->new(0);
 122         my $unavailCount = 0;
 123         for my $pos ( 0 .. $#aligned )
 124         {
 125             if( not defined( $aligned[$pos] ) )
 126             {
 127                 $aligned[$pos] = 0;
 128                 $unavailCount++;
 129             }
 130             else
 131             {
 132                 $sum += $aligned[$pos];
 133             }
 134         }
 135
 136         &Torrus::DB::checkInterrupted();
 137
 138         my $avgVal = $sum / $nDatapoints;
 139
 140         # Calculate the percentile
 141
 142         my @sorted = sort {$a <=> $b} @aligned;
 143         my $pcPos = floor( $nDatapoints * $percentile / 100 );
 144         my $pcVal = $sorted[$pcPos];
 145
 146         # Calculate the total volume if it's a counter
 147         my $volume = Math::BigFloat->new(0);
 148         my $volumeDefined = 0;
 149         if( not defined( $params->{'dstype'} ) or
 150             $params->{'dstype'} =~ /^COUNTER/o )
 151         {
 152             $volumeDefined = 1;
 153             for my $row ( @{$data} )
 154             {
 155                 $volume += $row->{'value'} * $row->{'intvl'};
 156             }
 157         }
 158
 159         # Adjust units and scale
 160
 161         my $usageUnits = '';
 162         my $volumeUnits = '';
 163         if( not defined( $params->{'units'} ) or
 164             $params->{'units'} eq 'bytes' )
 165         {
 166             # Adjust bytes into megabit per second
 167             $usageUnits = 'Mbps';
 168             $maxVal *= 8e-6;
 169             $avgVal *= 8e-6;
 170             $pcVal  *= 8e-6;
 171
 172             # Adjust volume bytes into megabytes
 173             $volumeUnits = 'GB';
 174             $volume /= 1073741824;
 175         }
 176
 177         $self->{'backend'}->addField( $self->{'reportId'}, {
 178             'name'      => 'MAX',
 179             'serviceid' => $serviceid,
 180             'value'     => $maxVal,
 181             'units'     => $usageUnits });
 182
 183         $self->{'backend'}->addField( $self->{'reportId'}, {
 184             'name'      => 'AVG',
 185             'serviceid' => $serviceid,
 186             'value'     => $avgVal,
 187             'units'     => $usageUnits });
 188
 189         $self->{'backend'}->addField( $self->{'reportId'}, {
 190             'name'      => sprintf('%s%s', $percentile, 'TH_PERCENTILE'),
 191             'serviceid' => $serviceid,
 192             'value'     => $pcVal,
 193             'units'     => $usageUnits });
 194
 195         $self->{'backend'}->addField( $self->{'reportId'}, {
 196             'name'      => 'UNAVAIL',
 197             'serviceid' => $serviceid,
 198             'value'     => ($unavailCount*100)/$nDatapoints,
 199             'units'     => '%' });
 200
 201         if( $volumeDefined )
 202         {
 203             $self->{'backend'}->addField( $self->{'reportId'}, {
 204                 'name'      => 'VOLUME',
 205                 'serviceid' => $serviceid,
 206                 'value'     => $volume,
 207                 'units'     => $volumeUnits });
 208         }
 209     }
 210
 211     &Torrus::DB::checkInterrupted();
 212
 213     $self->{'backend'}->finalize( $self->{'reportId'} );
 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: