Robot/contrib-munin
2
0
Fork 0
mirror of https://github.com/munin-monitoring/contrib.git synced 2018-11-08 00:59:34 +01:00
Code Issues Releases Wiki Activity
4b4a6a01e1
contrib-munin/plugins/system/irq
klemens 8589c6df43 spelling fixes (2nd try)
2017-04-17 22:43:38 +02:00

470 lines
14 KiB
Perl
Executable File
Raw Blame History

#!/usr/bin/perl -w
# -*- perl -*-
=head1 NAME
irq - Plugin to monitor interrupts.
=head1 APPLICABLE SYSTEMS
All Linux systems
=head1 CONFIGURATION
None need
=head2 WARNING AND CRITICAL SETTINGS
You can set warning and critical levels for each of the data
series the plugin reports.
'General' graph support cpu-irqtype limits and irqtype limits
Examples:
[irq]
env.warning_cpu1_sirq_total 550
env.critical_cpu0_irq_total 600
env.warning_irq_total 700
env.critical_sirq_total 700
'Child' graphs support cpu-irqtype-irqname and irqtype-irqname limits
Examples:
[irq]
env.warning_cpu0_irq_7 100
env.critical_cpu1_sirq_HI 100
env.warning_irq_LOC 100
env.critical_irq_12 200
env.warning_sirq_BLOCK 1000
Note: irqtype: sirq, irq; sirq - Software IRQ; irq name you can see in [] on graph
=head1 INTERPRETATION
The plugin shows each cpu interrupts: summary and IRQ/Software IRQ per CPU
=head1 MAGIC MARKERS
#%# family=auto
#%# capabilities=autoconf
=head1 VERSION
1.0
=head1 BUGS
I can not understand, how set limit to mirrored fields, so they may not display correctly
=head1 AUTHOR
Gorlow Maxim aka Sheridan <sheridan@sheridan-home.ru> (email and jabber)
=head1 LICENSE
GPLv2
=cut
use strict;
use warnings;
use Munin::Plugin;
use Data::Dumper;
my $IRQi = {};
my $graphs =
{
'irq_total' =>
{
'title' => 'Interrupts per cpu',
'args' => '--base 1000',
'vlabel' => 'count of IRQ (+) / sIRQ (-) per second',
'info' => 'This graph shows interrupts per second from last update',
'category' => 'system'
},
'irq_cpu' =>
{
'title' => 'CPU:cpu: :irq_type:',
'args' => '--base 1000',
'vlabel' => 'count per second',
'info' => 'This graph shows :irq_type: for CPU:cpu: per second from last update',
'category' => 'cpu :cpu:'
}
};
my $fields =
{
'irq' =>
{
'label' => '[:irq:] :irqinfo:',
'info' => ':irq:: :irqinfo:',
'type' => 'GAUGE',
'draw' => 'LINE1'
},
'irq_sirq' =>
{
'label' => 'CPU:cpu: sIRQ/IRQ',
'info' => 'Total sIRQ/IRQ for CPU:cpu:',
'type' => 'GAUGE',
'draw' => 'LINE1'
}
};
my $irq_types =
{
'irq' => 'Interrupts',
'sirq' => 'Software interrupts'
};
my $irq_descriptions =
{
'HI' => 'High priority tasklets',
'TIMER' => 'Timer bottom half',
'NET_TX' => 'Transmit network packets',
'NET_RX' => 'Receive network packets',
'SCSI' => 'SCSI bottom half',
'TASKLET' => 'Handles regular tasklets'
};
# ----------------- main ----------------
need_multigraph();
# -- autoconf --
if (defined($ARGV[0]) and ($ARGV[0] eq 'autoconf'))
{
printf("%s\n", (-e "/proc/interrupts" and -e "/proc/softirqs") ? "yes" : "no (stats not exists)");
exit (0);
}
# -- config --
load_irq_info();
if (defined($ARGV[0]) and ($ARGV[0] eq 'config')) { print_config(); exit (0); }
# -- values --
print_values(); exit(0);
# ----------------- sub's ----------------
# ----------------------- trim whitespace at begin and end of string ------------
sub trim
{
my ($string) = @_;
for ($string) { s/^\s+//; s/\s+$//; }
return $string;
}
# -------------------------- loading irq stats ---------------------------------
sub load_irq_info_file
{
my $file = $_[0];
my $info = {};
my $cpu_count = 0;
my $summ = 0;
open (FH, '<', $file) or die "$! $file \n";
for my $line (<FH>)
{
chomp $line;
if($line =~ m/:/)
{
my ($name, $stat) = split(/:/, trim($line));
my @data = split(/\s+/, trim($stat));
for (my $i=0; $i<$cpu_count; $i++)
{
if (defined $data[$i])
{
$info->{'info'}{$i}{$name} = $data[$i];
$info->{'summ'}{$i} += $data[$i];
}
}
if(scalar(@data) > $cpu_count)
{
my $iname = '';
($iname = $line) =~ s/^.*:(\s+\d+)+\s+(.*)$/$2/;
if ($iname ne '')
{
if ($iname =~ m/.*-.*-.*/)
{
my @parts = ($iname =~ /^((\w+-)*\w+)\s+(.*)\s*$/g);
$iname = sprintf("%s (%s)", $parts[0], $parts[2]);
}
$info->{'description'}{$name} = $iname;
}
}
elsif(exists ($irq_descriptions->{$name}))
{
$info->{'description'}{$name} = $irq_descriptions->{$name};
}
}
else
{
my @cpus = split(/\s+/, trim($line));
$cpu_count = scalar(@cpus);
for (my $i=0; $i<$cpu_count; $i++)
{
$info->{'summ'}{$i} = 0;
}
}
}
close (FH);
$info->{'cpu_count'} = $cpu_count;
return $info;
}
# -------------- loading all IRQ statistics ---------------------------
sub load_irq_info
{
my ($irq, $sirq) = (load_irq_info_file("/proc/interrupts"), load_irq_info_file("/proc/softirqs"));
$IRQi->{'stat'}{'irq' } = $irq ->{'info'};
$IRQi->{'stat'}{'sirq'} = $sirq->{'info'};
$IRQi->{'summ'}{'irq' } = $irq ->{'summ'};
$IRQi->{'summ'}{'sirq'} = $sirq->{'summ'};
$IRQi->{'description'}{'irq' } = $irq ->{'description'} if exists($irq ->{'description'});
$IRQi->{'description'}{'sirq'} = $sirq->{'description'} if exists($sirq->{'description'});
$IRQi->{'cpu_count'} = $irq ->{'cpu_count'};
}
# ------------------ loading limits ---------------------
sub load_limits
{
my $flags = {};
my $limits = {};
my $name = '';
for my $irq_type (qw(irq sirq))
{
for my $t (qw(warning critical))
{
$name = sprintf("%s_%s_total", $t, $irq_type); # env.warning_irq_total 22
$limits->{'irq_total'}{$irq_type}{$t} = $ENV{$name} || undef;
for (my $i=0; $i < $IRQi->{'cpu_count'}; $i++)
{
$name = sprintf("%s_cpu%s_%s_total", $t, $i, $irq_type); # env.warning_cpu1_sirq_total 1112
$limits->{'irq_total_percpu'}{$irq_type}{$t}{$i} = $ENV{$name} || undef;
for my $irq_name (keys %{$IRQi->{'stat'}{$irq_type}{$i}})
{
$name = sprintf("%s_cpu%s_%s_%s", $t, $i, $irq_type, $irq_name); # env.warning_cpu0_irq_7 25
$limits->{'percpu_perirq'}{$irq_type}{$t}{$i}{$irq_name} = $ENV{$name} || undef;
$name = sprintf("%s_%s_%s", $t, $irq_type, $irq_name);
unless (exists($flags->{$name}))
{
$limits->{'perirq'}{$irq_type}{$t}{$irq_name} = $ENV{$name} || undef; # env.critical_sirq_RCU 14
$flags->{$name} = 1;
}
}
}
}
}
return $limits;
}
# -------------------------------- replacing strings ------------------------
sub replace
{
my ($string, $needle, $replacement) = @_[0..2];
$string =~ s/$needle/$replacement/g;
return $string;
}
# ----------------- append limit values to general graph fields-----------------------------
sub append_total_limit
{
my ($limits, $gr, $irq_type, $field_name, $cpu_num) = @_[0..4];
for my $t (qw(warning critical))
{
my $limit = defined($limits->{'irq_total_percpu'}{$irq_type}{$t}{$cpu_num}) ? $limits->{'irq_total_percpu'}{$irq_type}{$t}{$cpu_num} :
($limits->{'irq_total'}{$irq_type}{$t} || undef);
if (defined($limit))
{
$gr->{'irq'}{'fields'}{$field_name}{$t} = $limit;
}
}
}
# ----------------- append limit values to chields graphs fields-----------------------------
sub append_cpu_limit
{
my ($limits, $gr, $irq_type, $field_name, $graph_name, $cpu_num, $irq_name) = @_[0..6];
for my $t (qw(warning critical))
{
my $limit = defined($limits->{'percpu_perirq'}{$irq_type}{$t}{$cpu_num}{$irq_name}) ? $limits->{'percpu_perirq'}{$irq_type}{$t}{$cpu_num}{$irq_name} :
($limits->{'perirq'}{$irq_type}{$t}{$irq_name} || undef);
if (defined($limit))
{
$gr->{$graph_name}{'fields'}{$field_name}{$t} = $limit;
}
}
}
# ------------------------------ preparing graphs configurations ------------------------------
sub prepare_graphs
{
my $gr = {};
my $limits = load_limits();
# --- general graph ---
$gr->{'irq'}{'graph'} = $graphs->{'irq_total'};
$gr->{'irq'}{'graph'}{'order'} = "";
for (my $i=0; $i < $IRQi->{'cpu_count'}; $i++)
{
# --- general fields ---
my ($up_field_name, $down_field_name) = (sprintf("i%s", $i), sprintf("si%s", $i));
append_total_limit($limits, $gr, 'irq', $up_field_name, $i);
append_total_limit($limits, $gr, 'sirq', $down_field_name, $i);
$gr->{'irq'}{'graph'}{'order'} .= sprintf(" %s %s", $down_field_name, $up_field_name);
$gr->{'irq'}{'fields'}{$up_field_name}{'type'} = $fields->{'irq_sirq'}{'type'};
$gr->{'irq'}{'fields'}{$down_field_name}{'type'} = $fields->{'irq_sirq'}{'type'};
$gr->{'irq'}{'fields'}{$up_field_name}{'draw'} = $fields->{'irq_sirq'}{'draw'};
$gr->{'irq'}{'fields'}{$down_field_name}{'draw'} = $fields->{'irq_sirq'}{'draw'};
$gr->{'irq'}{'fields'}{$up_field_name}{'label'} = replace($fields->{'irq_sirq'}{'label'}, ':cpu:', $i);
$gr->{'irq'}{'fields'}{$up_field_name}{'info'} = replace($fields->{'irq_sirq'}{'info'} , ':cpu:', $i);
$gr->{'irq'}{'fields'}{$down_field_name}{'label'} = 'NaN';
$gr->{'irq'}{'fields'}{$down_field_name}{'info'} = 'NaN';
$gr->{'irq'}{'fields'}{$up_field_name}{'negative'} = $down_field_name;
$gr->{'irq'}{'fields'}{$down_field_name}{'graph'} = 'no';
# --- child graphs ---
for my $irq_type (qw(irq sirq))
{
my $graph_name = sprintf("irq.%s_cpu%s", $irq_type, $i);
$gr->{$graph_name}{'graph'}{'order'} = "";
$gr->{$graph_name}{'graph'}{'args'} = $graphs->{'irq_cpu'}{'args'};
$gr->{$graph_name}{'graph'}{'vlabel'} = $graphs->{'irq_cpu'}{'vlabel'};
for my $go (qw(title info))
{
$gr->{$graph_name}{'graph'}{$go} = replace($graphs->{'irq_cpu'}{$go}, ':irq_type:', $irq_types->{$irq_type});
$gr->{$graph_name}{'graph'}{$go} = replace($gr->{$graph_name}{'graph'}{$go}, ':cpu:', $i);
}
$gr->{$graph_name}{'graph'}{'category'} = replace($graphs->{'irq_cpu'}{'category'}, ':cpu:', $i);
# -- child fields --
my @irq_names = keys %{$IRQi->{'stat'}{$irq_type}{$i}};
# names split for better sorting
for my $irq_name ((
(sort {int $a <=> int $b} grep{/^\d/} @irq_names),
(sort grep{!/(^\d|ERR|MIS)/} @irq_names),
(sort grep{/(ERR|MIS)/ } @irq_names)
))
{
my $field_name = clean_fieldname(sprintf("irq_%s", $irq_name));
append_cpu_limit($limits, $gr, $irq_type, $field_name, $graph_name, $i, $irq_name);
$gr->{$graph_name}{'graph'}{'order'} .= ' '.$field_name;
for my $fo (qw(label info))
{
$gr->{$graph_name}{'fields'}{$field_name}{$fo} = replace($fields->{'irq'}{$fo}, ':irq:', $irq_name);
$gr->{$graph_name}{'fields'}{$field_name}{$fo} = replace($gr->{$graph_name}{'fields'}{$field_name}{$fo},
':irqinfo:',
exists($IRQi->{'description'}{$irq_type}{$irq_name}) ?
$IRQi->{'description'}{$irq_type}{$irq_name} :
'');
}
$gr->{$graph_name}{'fields'}{$field_name}{'type'} = $fields->{'irq'}{'type'};
$gr->{$graph_name}{'fields'}{$field_name}{'draw'} = $fields->{'irq'}{'draw'};
}
}
}
return $gr;
}
# --------------------------------- graph configs ----------------------------
sub print_config
{
my $config = prepare_graphs();
for my $g (sort keys %{$config})
{
printf("multigraph %s\n", $g);
for my $go (sort keys %{$config->{$g}{'graph'}}) { printf("graph_%s %s\n", $go, $config->{$g}{'graph'}{$go}); }
for my $f (sort keys %{$config->{$g}{'fields'}}) { for my $fo (sort keys %{$config->{$g}{'fields'}{$f}}) { printf("%s.%s %s\n", $f, $fo, $config->{$g}{'fields'}{$f}{$fo}); } }
print "\n";
}
}
# ----------------------------------- saving state data using munin --------------------
sub save_state_data
{
my $data = $_[0];
my $d = Data::Dumper->new([$data]);
$d->Indent(0);
save_state($d->Dump);
}
# -------------------------------- loading previous state data using munin -------------------
sub restore_state_data
{
my $VAR1;
my $states = (restore_state())[0];
eval $states if defined $states;
return $VAR1;
}
# ----------------------------- loading statistic and save it for feature use--------------
sub load_stats
{
delete ($IRQi->{'description'});
$IRQi->{'timestamp'} = time();
save_state_data($IRQi);
return $IRQi;
}
# ----------- calculate current and previous values difference -----------------------
sub diff_value
{
my ($pvalue, $cvalue, $timediff) = @_[0..2];
return 'NaN' if $timediff <= 0 or $pvalue > $cvalue;
return ($cvalue - $pvalue)/$timediff;
}
# ----------------- calculating values ---------------------
sub calculate
{
my ($pstats, $cstats) = @_[0..1];
my $data = {};
my $timediff = $cstats->{'timestamp'} - $pstats->{'timestamp'};
for my $irq_type (qw(irq sirq))
{
for (my $i=0; $i < $IRQi->{'cpu_count'}; $i++)
{
$data->{'summ'}{$irq_type}{$i} = diff_value($pstats->{'summ'}{$irq_type}{$i}, $cstats->{'summ'}{$irq_type}{$i}, $timediff);
for my $irq_name (keys %{$cstats->{'stat'}{$irq_type}{$i}})
{
$data->{'stat'}{$irq_type}{$i}{$irq_name} = diff_value($pstats->{'stat'}{$irq_type}{$i}{$irq_name}, $cstats->{'stat'}{$irq_type}{$i}{$irq_name}, $timediff);
}
}
}
return $data;
}
# --------------------- preparing graphs values config ------------------------
sub prepare_graphs_values
{
my $data = $_[0];
my $values = {};
for (my $i=0; $i < $IRQi->{'cpu_count'}; $i++)
{
$values->{'irq'}{sprintf("i%s", $i)} = $data->{'summ'}{'irq'} {$i};
$values->{'irq'}{sprintf("si%s", $i)} = $data->{'summ'}{'sirq'}{$i};
for my $irq_type (qw(irq sirq))
{
my $graph_name = sprintf("irq.%s_cpu%s", $irq_type, $i);
for my $irq_name (keys %{$data->{'stat'}{$irq_type}{$i}})
{
my $field_name = clean_fieldname(sprintf("irq_%s", $irq_name));
$values->{$graph_name}{$field_name} = $data->{'stat'}{$irq_type}{$i}{$irq_name};
}
}
}
return $values;
}
# -------------------------------- printing values -----------------------------------
sub print_values
{
my $pstats = restore_state_data();
my $cstats = load_stats();
if (exists ($pstats->{'timestamp'}))
{
my $values = prepare_graphs_values(calculate($pstats, $cstats));
for my $g (sort keys %{$values})
{
printf("multigraph %s\n", $g);
for my $f (sort keys %{$values->{$g}}) { printf("%s.value %s\n", $f, $values->{$g}{$f}); }
print "\n";
}
}
}
Reference in New Issue View Git Blame Copy Permalink