860 lines
23 KiB
Perl
860 lines
23 KiB
Perl
#!/usr/bin/perl
|
|
#
|
|
# SERVER_stats.pl version 2.14
|
|
#
|
|
# This script gathers several system metrics and stores them in the MySQL database
|
|
#
|
|
# Copyright (C) 2026 Matt Florell <vicidial@gmail.com> LICENSE: AGPLv2
|
|
#
|
|
# CHANGES
|
|
# 240217-2226 - First build
|
|
# 260901-1011 - Look for mariadb-admin first, replacement for mysqladmin
|
|
#
|
|
|
|
$start_epoch = time();
|
|
|
|
# constants
|
|
$DB=0; # Debug flag, set to 0 for no debug messages, lots of output
|
|
$DBX=0;
|
|
$run_check=1; # concurrency check
|
|
$iodelay=60;
|
|
|
|
### begin parsing run-time options ###
|
|
if (length($ARGV[0])>1)
|
|
{
|
|
$i=0;
|
|
while ($#ARGV >= $i)
|
|
{
|
|
$args = "$args $ARGV[$i]";
|
|
$i++;
|
|
}
|
|
|
|
if ($args =~ /--help/i)
|
|
{
|
|
print "allowed run time options:\n";
|
|
print " [--test] = test\n";
|
|
print " [--debug] = verbose debug messages\n";
|
|
print " [--debugX] = Extra-verbose debug messages\n";
|
|
print " [--help] = this screen\n";
|
|
print "\n";
|
|
exit;
|
|
}
|
|
else
|
|
{
|
|
if ($args =~ /--debug/i)
|
|
{
|
|
$DB=1; # Debug flag
|
|
print "\n----- DEBUGGING ENABLED -----\n\n";
|
|
}
|
|
if ($args =~ /--debugX/i)
|
|
{
|
|
$DBX=1;
|
|
print "\n----- SUPER-DUPER DEBUGGING -----\n\n";
|
|
}
|
|
if ($args =~ /--test/i)
|
|
{
|
|
$TEST=1;
|
|
$T=1;
|
|
}
|
|
}
|
|
}
|
|
### end parsing run-time options ###
|
|
|
|
# default path to astguiclient configuration file:
|
|
$PATHconf = '/etc/astguiclient.conf';
|
|
|
|
open(conf, "$PATHconf") || die "can't open $PATHconf: $!\n";
|
|
@conf = <conf>;
|
|
close(conf);
|
|
$i=0;
|
|
foreach(@conf)
|
|
{
|
|
$line = $conf[$i];
|
|
$line =~ s/ |>|\n|\r|\t|\#.*|;.*//gi;
|
|
if ($line =~ /^PATHhome/) {$PATHhome = $line; $PATHhome =~ s/.*=//gi;}
|
|
if ($line =~ /^PATHlogs/) {$PATHlogs = $line; $PATHlogs =~ s/.*=//gi;}
|
|
if ($line =~ /^PATHagi/) {$PATHagi = $line; $PATHagi =~ s/.*=//gi;}
|
|
if ($line =~ /^PATHweb/) {$PATHweb = $line; $PATHweb =~ s/.*=//gi;}
|
|
if ($line =~ /^PATHsounds/) {$PATHsounds = $line; $PATHsounds =~ s/.*=//gi;}
|
|
if ($line =~ /^PATHmonitor/) {$PATHmonitor = $line; $PATHmonitor =~ s/.*=//gi;}
|
|
if ($line =~ /^VARserver_ip/) {$VARserver_ip = $line; $VARserver_ip =~ s/.*=//gi;}
|
|
if ($line =~ /^VARDB_server/) {$VARDB_server = $line; $VARDB_server =~ s/.*=//gi;}
|
|
if ($line =~ /^VARDB_database/) {$VARDB_database = $line; $VARDB_database =~ s/.*=//gi;}
|
|
if ($line =~ /^VARDB_user/) {$VARDB_user = $line; $VARDB_user =~ s/.*=//gi;}
|
|
if ($line =~ /^VARDB_pass/) {$VARDB_pass = $line; $VARDB_pass =~ s/.*=//gi;}
|
|
if ($line =~ /^VARDB_custom_user/) {$VARDB_custom_user = $line; $VARDB_custom_user =~ s/.*=//gi;}
|
|
if ($line =~ /^VARDB_custom_pass/) {$VARDB_custom_pass = $line; $VARDB_custom_pass =~ s/.*=//gi;}
|
|
if ($line =~ /^VARDB_port/) {$VARDB_port = $line; $VARDB_port =~ s/.*=//gi;}
|
|
$i++;
|
|
}
|
|
|
|
# Customized Variables
|
|
$server_ip = $VARserver_ip; # Asterisk server IP
|
|
|
|
|
|
### find df binary (partition usage)
|
|
$dfbin = '';
|
|
if ( -e ('/bin/df')) {$dfbin = '/bin/df';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/bin/df')) {$dfbin = '/usr/bin/df';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/local/bin/df')) {$dfbin = '/usr/local/bin/df';}
|
|
else
|
|
{
|
|
print "Can't find df binary! Exiting...\n";
|
|
exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
### find iostat binary (device IO usage)
|
|
$iostatbin = '';
|
|
if ( -e ('/bin/iostat')) {$iostatbin = '/bin/iostat';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/bin/iostat')) {$iostatbin = '/usr/bin/iostat';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/local/bin/iostat')) {$iostatbin = '/usr/local/bin/iostat';}
|
|
else
|
|
{
|
|
print "Can't find iostat binary! Exiting...\n";
|
|
exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
### find nproc binary (CPU count)
|
|
$nprocbin = '';
|
|
if ( -e ('/bin/nproc')) {$nprocbin = '/bin/nproc';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/bin/nproc')) {$nprocbin = '/usr/bin/nproc';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/local/bin/nproc')) {$nprocbin = '/usr/local/bin/nproc';}
|
|
else
|
|
{
|
|
print "Can't find nproc binary! Exiting...\n";
|
|
exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
### find uptime binary
|
|
if ( -e ('/bin/uptime')) {$uptimebin = '/bin/uptime';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/bin/uptime')) {$uptimebin = '/usr/bin/uptime';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/local/bin/uptime')) {$uptimebin = '/usr/local/bin/uptime';}
|
|
else
|
|
{
|
|
print "Can't find uptime binary!\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
### find hostname binary (line and word count)
|
|
$hostnamebin = '';
|
|
if ( -e ('/bin/hostname')) {$hostnamebin = '/bin/hostname';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/bin/hostname')) {$hostnamebin = '/usr/bin/hostname';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/local/bin/hostname')) {$hostnamebin = '/usr/local/bin/hostname';}
|
|
else
|
|
{
|
|
if ($DB > 0) {print "Can't find hostname binary, not going to gather database info.\n";}
|
|
}
|
|
}
|
|
}
|
|
|
|
### find mysqladmin (or mariadb-admin) binary (database admin)
|
|
$mysqladminbin = '';
|
|
if ( -e ('/usr/bin/mariadb-admin')) {$mysqladminbin = '/usr/bin/mariadb-admin';}
|
|
else
|
|
{
|
|
if ( -e ('/bin/mariadb-admin')) {$mysqladminbin = '/bin/mariadb-admin';}
|
|
else
|
|
{
|
|
if ( -e ('/bin/mysqladmin')) {$mysqladminbin = '/bin/mysqladmin';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/bin/mysqladmin')) {$mysqladminbin = '/usr/bin/mysqladmin';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/local/bin/mysqladmin')) {$mysqladminbin = '/usr/local/bin/mysqladmin';}
|
|
else
|
|
{
|
|
if ($DB > 0) {print "Can't find mysqladmin binary, not going to gather database info.\n";}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
### find wc binary (line and word count)
|
|
$wcbin = '';
|
|
if ( -e ('/bin/wc')) {$wcbin = '/bin/wc';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/bin/wc')) {$wcbin = '/usr/bin/wc';}
|
|
else
|
|
{
|
|
if ( -e ('/usr/local/bin/wc')) {$wcbin = '/usr/local/bin/wc';}
|
|
else
|
|
{
|
|
if ($DB > 0) {print "Can't find wc binary, not going to gather database info.\n";}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (!$VARDB_port) {$VARDB_port='3306';}
|
|
|
|
|
|
&get_time_now;
|
|
|
|
#use lib './lib', '../lib';
|
|
use Time::HiRes ('gettimeofday','usleep','sleep'); # necessary to have perl sleep command of less than one second
|
|
use DBI;
|
|
use Switch;
|
|
use POSIX;
|
|
use Scalar::Util qw(looks_like_number);
|
|
|
|
|
|
$dbhA = DBI->connect("DBI:mysql:$VARDB_database:$VARDB_server:$VARDB_port", "$VARDB_user", "$VARDB_pass")
|
|
or die "Couldn't connect to database: " . DBI->errstr;
|
|
|
|
### concurrency check (SCREEN uses script path, so check for more than 2 entries)
|
|
if ($run_check > 0)
|
|
{
|
|
my $grepout = `/bin/ps ax | grep $0 | grep -v grep | grep -v '/bin/sh'`;
|
|
my $grepnum=0;
|
|
$grepnum++ while ($grepout =~ m/\n/g);
|
|
if ($grepnum > 2)
|
|
{
|
|
if ($DB) {print "I am not alone! Another $0 is running! Exiting...\n";}
|
|
$event_string = "I am not alone! Another $0 is running! Exiting...";
|
|
&event_logger($SYSLOG,$event_string);
|
|
exit;
|
|
}
|
|
}
|
|
|
|
|
|
$event_string="STARTING NEW STATS GRAB";
|
|
event_logger($SYSLOG,$event_string);
|
|
|
|
# insert/update server_live_stats record in the DB
|
|
$stmtA = "INSERT INTO server_live_stats set update_time=NOW(), server_ip='$server_ip' ON DUPLICATE KEY UPDATE update_time=NOW();";
|
|
if($DB){print STDERR "\n$stmtA\n";}
|
|
$dbhA->do($stmtA);
|
|
$affected_rows = $dbhA->do($stmtA);
|
|
|
|
|
|
# gather server stats
|
|
$MYSQLuptime=0; $MYSQLconnections=0; $MYSQLqueries=0;
|
|
|
|
$hostname = get_hostname();
|
|
|
|
$cpu_count = get_cpu_count();
|
|
|
|
( $loadavg_1, $loadavg_5, $loadavg_15 ) = get_cpu_load();
|
|
|
|
( $mem_total, $mem_used, $mem_free ) = get_mem_usage();
|
|
|
|
$num_processes = get_num_processes();
|
|
|
|
$system_uptime = get_uptime();
|
|
|
|
( $cpu_user_percent,
|
|
$cpu_idle_percent,
|
|
$cpu_iowait_percent,
|
|
$cpu_sys_percent,
|
|
$cpu_vm_percent,
|
|
$user_diff,
|
|
$nice_diff,
|
|
$system_diff,
|
|
$idle_diff,
|
|
$iowait_diff,
|
|
$irq_diff,
|
|
$softirq_diff,
|
|
$steal_diff,
|
|
$guest_diff,
|
|
$guest_nice_diff ) = get_cpu_percent();
|
|
|
|
( $reads, $writes ) = get_disk_rw();
|
|
|
|
my ( $asterisk_channels_total, $asterisk_agents_total ) = get_asterisk_data($dbhA,$server_ip);
|
|
|
|
if (length($mysqladminbin) > 2)
|
|
{
|
|
$mysql_data_begin = time();
|
|
( $MYSQLuptime, $MYSQLconnections, $MYSQLqueries ) = get_mysqlstatus();
|
|
$MYSQLqueriesOLD = $MYSQLqueries;
|
|
}
|
|
|
|
|
|
# insert/update server_live_stats record in the DB
|
|
$stmtA = "UPDATE server_live_stats set update_time=NOW(),server_name='$hostname',cpu_count='$cpu_count',loadavg_1='$loadavg_1',loadavg_5='$loadavg_5',loadavg_15='$loadavg_15',freeram='$mem_free',usedram='$mem_used',processes='$num_processes',system_uptime='$system_uptime',asterisk_channels_total='$asterisk_channels_total',asterisk_agents_total='$asterisk_agents_total',mysql_uptime='$MYSQLuptime',mysql_connections='$MYSQLconnections' WHERE server_ip='$server_ip';";
|
|
if($DB){print STDERR "\n$stmtA\n";}
|
|
$dbhA->do($stmtA);
|
|
$affected_rows = $dbhA->do($stmtA);
|
|
|
|
|
|
my $disk_usage = get_disk_space($dbhA,$server_ip);
|
|
|
|
my $storage_devices = get_disk_io($dbhA,$server_ip);
|
|
|
|
( $reads, $writes ) = get_disk_rw();
|
|
|
|
( $cpu_user_percent,
|
|
$cpu_idle_percent,
|
|
$cpu_iowait_percent,
|
|
$cpu_sys_percent,
|
|
$cpu_vm_percent,
|
|
$user_diff,
|
|
$nice_diff,
|
|
$system_diff,
|
|
$idle_diff,
|
|
$iowait_diff,
|
|
$irq_diff,
|
|
$softirq_diff,
|
|
$steal_diff,
|
|
$guest_diff,
|
|
$guest_nice_diff ) = get_cpu_percent();
|
|
$read_write_cpu_SQL = "disk_reads='$reads',disk_writes='$writes',cpu_user_percent='$cpu_user_percent',cpu_sys_percent='$cpu_sys_percent',cpu_idle_percent='$cpu_idle_percent',cpu_iowait_percent='$cpu_iowait_percent',cpu_vm_percent='$cpu_vm_percent'";
|
|
|
|
if (length($mysqladminbin) > 2)
|
|
{
|
|
$mysql_data_end = time();
|
|
( $MYSQLuptime, $MYSQLconnections, $MYSQLqueries ) = get_mysqlstatus();
|
|
|
|
$MYSQLqueriesTEMP = ($MYSQLqueries - $MYSQLqueriesOLD);
|
|
$mysql_data_sec = ($mysql_data_end - $mysql_data_begin);
|
|
$mysql_queries_per_second = sprintf("%.0f", ($MYSQLqueriesTEMP / $mysql_data_sec));
|
|
|
|
if($DB){print STDERR "\n$MYSQLqueriesTEMP = ($MYSQLqueries - $MYSQLqueriesOLD)\n";}
|
|
|
|
# update server_live_stats record in the DB
|
|
$stmtA = "UPDATE server_live_stats set update_time=NOW(),mysql_uptime='$MYSQLuptime',mysql_connections='$MYSQLconnections',mysql_queries_per_second='$mysql_queries_per_second',$read_write_cpu_SQL WHERE server_ip='$server_ip';";
|
|
if($DB){print STDERR "\n$stmtA\n";}
|
|
$dbhA->do($stmtA);
|
|
$affected_rows = $dbhA->do($stmtA);
|
|
}
|
|
else
|
|
{
|
|
# update server_live_stats record in the DB
|
|
$stmtA = "UPDATE server_live_stats set update_time=NOW(),$read_write_cpu_SQL WHERE server_ip='$server_ip';";
|
|
if($DB){print STDERR "\n$stmtA\n";}
|
|
$dbhA->do($stmtA);
|
|
$affected_rows = $dbhA->do($stmtA);
|
|
}
|
|
|
|
|
|
|
|
$event_string='FINISHING UP|';
|
|
event_logger($SYSLOG,$event_string);
|
|
|
|
|
|
$sthA->finish();
|
|
$dbhA->disconnect();
|
|
|
|
$end_epoch = time();
|
|
$run_time = ($end_epoch - $start_epoch);
|
|
|
|
if($DB){print "DONE... Exiting... Goodbye... See you later! runtime: $run_time seconds \n";}
|
|
|
|
|
|
exit;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#################### SUBROUTINES #########################
|
|
|
|
sub event_logger
|
|
{
|
|
my ($SYSLOG,$event_string) = @_;
|
|
if ($SYSLOG)
|
|
{
|
|
### open the log file for writing ###
|
|
open(Lout, ">>$PATHlogs/server_stats.$action_log_date")
|
|
|| die "Can't open $PATHlogs/server_stats.$action_log_date: $!\n";
|
|
print Lout "$now_date|$event_string|\n";
|
|
close(Lout);
|
|
}
|
|
$event_string='';
|
|
}
|
|
|
|
sub get_time_now #get the current date and time and epoch for logging call lengths and datetimes
|
|
{
|
|
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
|
|
$year = ($year + 1900);
|
|
$mon++;
|
|
if ($mon < 10) {$mon = "0$mon";}
|
|
if ($mday < 10) {$mday = "0$mday";}
|
|
if ($hour < 10) {$hour = "0$hour";}
|
|
if ($min < 10) {$min = "0$min";}
|
|
if ($sec < 10) {$sec = "0$sec";}
|
|
|
|
$now_date_epoch = time();
|
|
$now_date = "$year-$mon-$mday $hour:$min:$sec";
|
|
$action_log_date = "$year-$mon-$mday";
|
|
}
|
|
|
|
|
|
|
|
sub print_now
|
|
{
|
|
my $string = shift;
|
|
|
|
# get the current time in microseconds
|
|
my ( $now_sec, $now_micro_sec ) = gettimeofday();
|
|
|
|
# figure out how many micro seconds since epoch
|
|
my $now_micro_epoch = $now_sec * 1000000;
|
|
$now_micro_epoch = $now_micro_epoch + $now_micro_sec;
|
|
|
|
print "\n$string|$now_micro_epoch\n\n";
|
|
}
|
|
|
|
|
|
sub get_cpu_percent
|
|
{
|
|
# stat file in proc
|
|
$stat = '/proc/stat';
|
|
|
|
# read it
|
|
open( FH , "<$stat" );
|
|
@lines = <FH>;
|
|
close( FH );
|
|
|
|
# get the various times spent doing stuff ( $cpu is useless )
|
|
($cpu, $user, $nice, $system, $idle, $iowait, $irq, $softirq, $steal, $guest, $guest_nice ) = split( ' ', $lines[0] );
|
|
|
|
# total the different catagories of time
|
|
$cpu_user = $user + $nice;
|
|
$cpu_idle = $idle;
|
|
$cpu_iowait = $iowait;
|
|
$cpu_sys = $system + $irq + $softirq;
|
|
$cpu_vm = $steal + $guest + $guest_nice;
|
|
|
|
# check if we have previous values
|
|
if ( defined ( $prev_user ) )
|
|
{
|
|
# get the differential from last time
|
|
$cpu_user_diff = $cpu_user - $prev_cpu_user;
|
|
$cpu_idle_diff = $cpu_idle - $prev_cpu_idle;
|
|
$cpu_iowait_diff = $cpu_iowait - $prev_cpu_iowait;
|
|
$cpu_sys_diff = $cpu_sys - $prev_cpu_sys;
|
|
$cpu_vm_diff = $cpu_vm - $prev_cpu_vm;
|
|
|
|
$user_diff = $user - $prev_user;
|
|
$nice_diff = $nice - $prev_nice;
|
|
$system_diff = $system - $prev_system;
|
|
$idle_diff = $idle - $prev_idle;
|
|
$iowait_diff = $iowait - $prev_iowait;
|
|
$irq_diff = $irq - $prev_irq;
|
|
$softirq_diff = $softirq - $prev_softirq;
|
|
$steal_diff = $steal - $prev_steal;
|
|
$guest_diff = $guest - $prev_guest;
|
|
$guest_nice_diff = $guest_nice - $prev_guest_nice;
|
|
|
|
# total the differentials
|
|
$cpu_total_diff = $cpu_user_diff + $cpu_idle_diff + $cpu_sys_diff + $cpu_vm_diff + $cpu_iowait_diff;
|
|
|
|
$cpu_user_percent = sprintf("%.2f", (( $cpu_user_diff / $cpu_total_diff ) * 100 ));
|
|
$cpu_idle_percent = sprintf("%.2f", (( $cpu_idle_diff / $cpu_total_diff ) * 100 ));
|
|
$cpu_iowait_percent = sprintf("%.2f", (( $cpu_iowait_diff / $cpu_total_diff ) * 100 ));
|
|
$cpu_sys_percent = sprintf("%.2f", (( $cpu_sys_diff / $cpu_total_diff ) * 100 ));
|
|
$cpu_vm_percent = sprintf("%.2f", (( $cpu_vm_diff / $cpu_total_diff ) * 100 ));
|
|
}
|
|
else
|
|
{
|
|
# first time runnings so there are no previous values.
|
|
# all we can do is base it off the system totals since boot.
|
|
$cpu_total = $cpu_user + $cpu_idle + $cpu_sys + $cpu_vm;
|
|
|
|
$cpu_user_percent = sprintf("%.2f", (( $cpu_user / $cpu_total ) * 100 ));
|
|
$cpu_idle_percent = sprintf("%.2f", (( $cpu_idle / $cpu_total ) * 100 ));
|
|
$cpu_iowait_percent = sprintf("%.2f", (( $cpu_iowait / $cpu_total ) * 100 ));
|
|
$cpu_sys_percent = sprintf("%.2f", (( $cpu_sys / $cpu_total ) * 100 ));
|
|
$cpu_vm_percent = sprintf("%.2f", (( $cpu_vm / $cpu_total ) * 100 ));
|
|
}
|
|
|
|
# store the values for the next call
|
|
$prev_user = $user;
|
|
$prev_nice = $nice;
|
|
$prev_system = $system;
|
|
$prev_idle = $idle;
|
|
$prev_iowait = $iowait;
|
|
$prev_irq = $irq;
|
|
$prev_softirq = $softirq;
|
|
$prev_steal = $steal;
|
|
$prev_guest = $guest;
|
|
$prev_guest_nice = $guest_nice;
|
|
$prev_cpu_user = $cpu_user;
|
|
$prev_cpu_idle = $cpu_idle;
|
|
$prev_cpu_iowait = $cpu_iowait;
|
|
$prev_cpu_sys = $cpu_sys;
|
|
$prev_cpu_vm = $cpu_vm;
|
|
|
|
return (
|
|
$cpu_user_percent,
|
|
$cpu_idle_percent,
|
|
$cpu_iowait_percent,
|
|
$cpu_sys_percent,
|
|
$cpu_vm_percent,
|
|
$user_diff,
|
|
$nice_diff,
|
|
$system_diff,
|
|
$idle_diff,
|
|
$iowait_diff,
|
|
$irq_diff,
|
|
$softirq_diff,
|
|
$steal_diff,
|
|
$guest_diff,
|
|
$guest_nice_diff
|
|
);
|
|
}
|
|
|
|
|
|
sub get_cpu_load
|
|
{
|
|
$lavg = '/proc/loadavg';
|
|
|
|
open( FH , "<$lavg" );
|
|
@lines = <FH>;
|
|
close( FH );
|
|
|
|
@loadavg_data = split(' ',$lines[0]);
|
|
$loadavg_1 = $loadavg_data[0];
|
|
$loadavg_5 = $loadavg_data[1];
|
|
$loadavg_15 = $loadavg_data[2];
|
|
|
|
return ( $loadavg_1, $loadavg_5, $loadavg_15 );
|
|
}
|
|
|
|
|
|
sub get_mem_usage
|
|
{
|
|
$meminfo = '/proc/meminfo';
|
|
|
|
open( FH , "<$meminfo" );
|
|
@lines = <FH>;
|
|
close( FH );
|
|
|
|
$mem_total = $lines[0];
|
|
$mem_total =~ s/MemTotal: *//g;
|
|
|
|
$mem_free = $lines[1];
|
|
$mem_free =~ s/MemFree: *//g;
|
|
|
|
$mem_used = $mem_total - $mem_free;
|
|
|
|
$mem_used = floor( $mem_used / 1024 );
|
|
$mem_total = floor( $mem_total / 1024 );
|
|
$mem_free = floor( $mem_free / 1023 );
|
|
|
|
return ( $mem_total, $mem_used, $mem_free );
|
|
}
|
|
|
|
|
|
sub get_disk_space
|
|
{
|
|
my ($dbhA,$server_ip) = @_;
|
|
|
|
# df -B 1048576 -x nfs -x cifs -x sshfs -x ftpfs
|
|
#Filesystem 1M-blocks Used Available Use% Mounted on
|
|
#devtmpfs 4 0 4 0% /dev
|
|
#tmpfs 64395 1 64395 1% /dev/shm
|
|
#tmpfs 25758 42 25717 1% /run
|
|
#tmpfs 4 0 4 0% /sys/fs/cgroup
|
|
#/dev/md0 933742 99229 787010 12% /
|
|
#tmpfs 6144 0 6144 0% /var/spool/asterisk/monitor
|
|
#/dev/md2 937801 363804 531254 41% /srv/mysql
|
|
#tmpfs 12879 0 12879 0% /run/user/0
|
|
|
|
@serverDISK = `$dfbin -B 1048576 -x nfs -x cifs -x sshfs -x ftpfs`;
|
|
$ct=0;
|
|
$ct_PCT=0;
|
|
$disk_usage = '';
|
|
foreach(@serverDISK)
|
|
{
|
|
if ($serverDISK[$ct] =~ /(\d+\%)/)
|
|
{
|
|
$usage = $1;
|
|
$usage =~ s/\%//gi;
|
|
$disk_usage .= "$ct_PCT $usage|";
|
|
$partition_path = $serverDISK[$ct];
|
|
$partition_path =~ s/.*\% |\r|\n|\t//gi;
|
|
$partition_filesystem = $serverDISK[$ct];
|
|
$partition_filesystem =~ s/ .*|\r|\n|\t//gi;
|
|
$disk_data = $serverDISK[$ct];
|
|
$disk_data =~ s/\s+/ /gi;
|
|
@disk_dataARY = split(/ /,$disk_data);
|
|
$mb_used = $disk_dataARY[2];
|
|
$mb_available = $disk_dataARY[3];
|
|
|
|
# insert/update server_live_drives record in the DB
|
|
$stmtA = "INSERT INTO server_live_partitions set server_ip='$server_ip',partition_path='$partition_path',update_time=NOW(),partition_order='$ct_PCT',partition_filesystem='$partition_filesystem',use_pct='$usage',mb_used='$mb_used',mb_available='$mb_available' ON DUPLICATE KEY UPDATE update_time=NOW(),partition_order='$ct_PCT',partition_filesystem='$partition_filesystem',use_pct='$usage',mb_used='$mb_used',mb_available='$mb_available';";
|
|
if($DB){print STDERR "\n$stmtA\n";}
|
|
$dbhA->do($stmtA);
|
|
$affected_rows = $dbhA->do($stmtA);
|
|
|
|
$ct_PCT++;
|
|
}
|
|
$ct++;
|
|
}
|
|
|
|
return $disk_usage;
|
|
}
|
|
|
|
|
|
sub get_disk_io
|
|
{
|
|
my ($dbhA,$server_ip) = @_;
|
|
|
|
$ct_DEVICES = -1;
|
|
# Device r/s w/s rkB/s wkB/s rrqm/s wrqm/s %rrqm %wrqm r_await w_await aqu-sz rareq-sz wareq-sz svctm %util
|
|
# nvme0n1 2.22 23.56 10.10 129.77 0.00 7.24 0.00 23.50 2.13 0.68 0.03 4.55 5.51 0.95 2.45
|
|
# @serverDISKio = `$iostatbin -yx 59 1`;
|
|
@serverDISKioVERSION = `$iostatbin -V`;
|
|
$IOSTATversion = $serverDISKioVERSION[0];
|
|
$IOSTATversion =~ s/.*version |\..*//gi;
|
|
$IOSTATversion =~ s/\D//gi;
|
|
if ($IOSTATversion >= 11)
|
|
{
|
|
@serverDISKio = `$iostatbin -yx $iodelay 1`;
|
|
$ct=0;
|
|
$devices_trigger=0;
|
|
$ct_DEVICES=0;
|
|
$disk_io = '';
|
|
foreach(@serverDISKio)
|
|
{
|
|
if ($serverDISKio[$ct] =~ /^Device/)
|
|
{$devices_trigger++;}
|
|
else
|
|
{
|
|
if ( ($devices_trigger > 0) && (length($serverDISKio[$ct]) > 14) )
|
|
{
|
|
$drive_order[$ct_DEVICES] = $ct_DEVICES;
|
|
$drive_device[$ct_DEVICES] = substr($serverDISKio[$ct],0,13);
|
|
$read_sec[$ct_DEVICES] = substr($serverDISKio[$ct],13,8);
|
|
$write_sec[$ct_DEVICES] = substr($serverDISKio[$ct],21,8);
|
|
$kb_read_sec[$ct_DEVICES] = substr($serverDISKio[$ct],29,10);
|
|
$kb_write_sec[$ct_DEVICES] = substr($serverDISKio[$ct],39,10);
|
|
$util_pct[$ct_DEVICES] = substr($serverDISKio[$ct],129,7);
|
|
|
|
$drive_device[$ct_DEVICES] =~ s/\s//gi;
|
|
$read_sec[$ct_DEVICES] =~ s/\s//gi;
|
|
$write_sec[$ct_DEVICES] =~ s/\s//gi;
|
|
$kb_read_sec[$ct_DEVICES] =~ s/\s//gi;
|
|
$kb_write_sec[$ct_DEVICES] =~ s/\s//gi;
|
|
$util_pct[$ct_DEVICES] =~ s/\s//gi;
|
|
|
|
# insert/update server_live_drives record in the DB
|
|
$stmtA = "INSERT INTO server_live_drives set server_ip='$server_ip',drive_device='$drive_device[$ct_DEVICES]',update_time=NOW(),drive_order='$drive_order[$ct_DEVICES]',read_sec='$read_sec[$ct_DEVICES]',write_sec='$write_sec[$ct_DEVICES]',kb_read_sec='$kb_read_sec[$ct_DEVICES]',kb_write_sec='$kb_write_sec[$ct_DEVICES]',util_pct='$util_pct[$ct_DEVICES]' ON DUPLICATE KEY UPDATE update_time=NOW(),drive_order='$drive_order[$ct_DEVICES]',read_sec='$read_sec[$ct_DEVICES]',write_sec='$write_sec[$ct_DEVICES]',kb_read_sec='$kb_read_sec[$ct_DEVICES]',kb_write_sec='$kb_write_sec[$ct_DEVICES]',util_pct='$util_pct[$ct_DEVICES]';";
|
|
if($DB){print STDERR "\n$stmtA\n";}
|
|
$dbhA->do($stmtA);
|
|
$affected_rows = $dbhA->do($stmtA);
|
|
|
|
$ct_DEVICES++;
|
|
}
|
|
}
|
|
$ct++;
|
|
}
|
|
}
|
|
|
|
return $ct_DEVICES;
|
|
}
|
|
|
|
|
|
sub get_cpu_count
|
|
{
|
|
@serverNPROC = `$nprocbin`;
|
|
$ct_CPUS = $serverNPROC[0];
|
|
$ct_CPUS =~ s/\D//gi;
|
|
|
|
return $ct_CPUS;
|
|
}
|
|
|
|
|
|
sub get_hostname
|
|
{
|
|
@serverHOSTNAME = `$hostnamebin`;
|
|
$hostname = $serverHOSTNAME[0];
|
|
$hostname =~ s/\n|\r|\t//gi;
|
|
|
|
return $hostname;
|
|
}
|
|
|
|
|
|
sub get_uptime
|
|
{
|
|
@sysuptime = `$uptimebin`;
|
|
# 18:26:14 up 153 days, 23:59, 4 users, load average: 0.01, 0.01, 0.00
|
|
# 10:03am up 123 days 0:10, 1 user, load average: 0.11, 0.05, 0.01
|
|
# 10:03am up 3:17, 2 users, load average: 0.41, 0.28, 0.21
|
|
|
|
if ($DBX) {print "Uptime debug 1: |$sysuptime[0]|\n";}
|
|
$sysuptime[0] =~ s/ days, / days /gi;
|
|
$sysuptime[0] =~ s/,.*//gi;
|
|
$sysuptime[0] =~ s/ / /gi;
|
|
$sysuptime[0] =~ s/ / /gi;
|
|
$sysuptime[0] =~ s/\r|\n|\t//gi;
|
|
@uptimedata = split(/ up /,$sysuptime[0]);
|
|
$system_uptime = $uptimedata[1];
|
|
|
|
return $system_uptime;
|
|
}
|
|
|
|
|
|
sub get_num_processes
|
|
{
|
|
$num_processes = 0;
|
|
|
|
opendir( DH, '/proc');
|
|
while ( readdir( DH ) )
|
|
{
|
|
if ( looks_like_number( $_ ) ) { $num_processes++; }
|
|
}
|
|
closedir( DH );
|
|
|
|
return ($num_processes);
|
|
}
|
|
|
|
|
|
sub get_disk_rw
|
|
{
|
|
$total_reads = 0;
|
|
$total_writes = 0;
|
|
|
|
$diskstats = "/proc/diskstats";
|
|
|
|
open( FH , "<$diskstats" );
|
|
@lines = <FH>;
|
|
close( FH );
|
|
|
|
foreach $line ( @lines )
|
|
{
|
|
# remove excess white space
|
|
$line =~ s/\h+/ /g;
|
|
$line =~ s/^\s+|\s+$//g;
|
|
|
|
# split the line
|
|
(
|
|
$major,
|
|
$minor,
|
|
$device,
|
|
$reads_completed,
|
|
$reads_merged,
|
|
$sectors_read,
|
|
$time_reading,
|
|
$writes_completed,
|
|
$writes_merged,
|
|
$sectors_written,
|
|
$time_writing,
|
|
$current_ios,
|
|
$ios_time,
|
|
$weighted_ios_time
|
|
) = split( ' ', $line );
|
|
|
|
# check if device is a drive or partition or raid
|
|
if ( $device !~ /\d/ )
|
|
{
|
|
$total_reads += $sectors_read;
|
|
$total_writes += $sectors_written;
|
|
}
|
|
}
|
|
|
|
# check if we previously got the total reads
|
|
if ( defined ( $prev_total_reads ) )
|
|
{
|
|
$reads = $total_reads - $prev_total_reads;
|
|
$writes = $total_writes - $prev_total_writes;
|
|
}
|
|
else
|
|
{
|
|
# cannot figure out the difference
|
|
# if we don't know what it was before
|
|
$reads = 0;
|
|
$writes = 0;
|
|
}
|
|
|
|
$prev_total_reads = $total_reads;
|
|
$prev_total_writes = $total_writes;
|
|
|
|
return ( $reads, $writes );
|
|
}
|
|
|
|
|
|
sub get_asterisk_data
|
|
{
|
|
my ($dbhA,$server_ip) = @_;
|
|
|
|
$live_channels=0;
|
|
$stmtA = "SELECT count(*) FROM live_channels where server_ip='$server_ip';";
|
|
$sthA = $dbhA->prepare($stmtA) or die "preparing: ",$dbhA->errstr;
|
|
$sthA->execute or die "executing: $stmtA ", $dbhA->errstr;
|
|
@aryA = $sthA->fetchrow_array;
|
|
$live_channels = $aryA[0];
|
|
if($DB){print STDERR "\n|$live_channels|$stmtA|\n";}
|
|
|
|
$live_sip_channels=0;
|
|
$stmtA = "SELECT count(*) FROM live_sip_channels where server_ip='$server_ip';";
|
|
$sthA = $dbhA->prepare($stmtA) or die "preparing: ",$dbhA->errstr;
|
|
$sthA->execute or die "executing: $stmtA ", $dbhA->errstr;
|
|
@aryA = $sthA->fetchrow_array;
|
|
$live_sip_channels = $aryA[0];
|
|
if($DB){print STDERR "\n|$live_sip_channels|$stmtA|\n";}
|
|
$total_channels = ($live_channels + $live_sip_channels);
|
|
|
|
$live_agents=0;
|
|
$stmtA = "SELECT count(*) FROM vicidial_live_agents where server_ip='$server_ip';";
|
|
$sthA = $dbhA->prepare($stmtA) or die "preparing: ",$dbhA->errstr;
|
|
$sthA->execute or die "executing: $stmtA ", $dbhA->errstr;
|
|
@aryA = $sthA->fetchrow_array;
|
|
$live_agents = $aryA[0];
|
|
if($DB){print STDERR "\n|$live_agents|$stmtA|\n";}
|
|
|
|
return ( $total_channels, $live_agents );
|
|
}
|
|
|
|
|
|
sub get_mysqlstatus
|
|
{
|
|
# Uptime: 3848845 Threads: 1 Questions: 231036439 Slow queries: 46 Opens: 54008 Flush tables: 2 Open tables: 64 Queries per second avg: 60.027
|
|
@serverMYSQL = `$mysqladminbin status`;
|
|
$MYSQLuptime=0;
|
|
$MYSQLthreads=0;
|
|
$MYSQLqueries=0;
|
|
$MYSQLconnections=0;
|
|
@mysql_status_data = split(' ',$serverMYSQL[0]);
|
|
$MYSQLuptime = $mysql_status_data[0];
|
|
$MYSQLuptime =~ s/\D//gi;
|
|
$MYSQLthreads = $mysql_status_data[1];
|
|
$MYSQLthreads =~ s/\D//gi;
|
|
$MYSQLqueries = $mysql_status_data[2];
|
|
$MYSQLqueries =~ s/\D//gi;
|
|
|
|
if($DB){print STDERR "\n $mysqladminbin processlist | $wcbin \n";}
|
|
|
|
@serverMYSQLconnections = `$mysqladminbin processlist | $wcbin`;
|
|
$connection_data = $serverMYSQLconnections[0];
|
|
$connection_data =~ s/\s+/ /gi;
|
|
@serverMYSQLconnectionsARY = split(/ /,$connection_data);
|
|
$MYSQLconnections = ($serverMYSQLconnectionsARY[1] - 4);
|
|
|
|
return ( $MYSQLuptime, $MYSQLconnections, $MYSQLqueries );
|
|
}
|