2015-07-15 13:58:20 +00:00
#!/usr/bin/env perl
2016-08-30 12:48:48 +00:00
# mysqltuner.pl - Version 1.6.18
2008-09-08 01:16:39 +00:00
# High Performance MySQL Tuning Script
2016-03-24 22:58:48 +00:00
# Copyright (C) 2006-2016 Major Hayden - major@mhtx.net
2008-09-08 01:16:39 +00:00
#
# For the latest updates, please visit http://mysqltuner.com/
2014-02-22 01:43:08 +00:00
# Git repository available at http://github.com/major/MySQLTuner-perl
2008-09-08 01:16:39 +00:00
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# This project would not be possible without help from:
2009-09-17 23:24:33 +00:00
# Matthew Montgomery Paul Kehrer Dave Burgess
# Jonathan Hinds Mike Jackson Nils Breunese
# Shawn Ashlee Luuk Vosslamber Ville Skytta
# Trent Hornibrook Jason Gill Mark Imbriaco
# Greg Eden Aubin Galinotti Giovanni Bechis
# Bill Bradford Ryan Novosielski Michael Scheidell
# Blair Christensen Hans du Plooy Victor Trac
# Everett Barnes Tom Krouper Gary Barrueto
# Simon Greenaway Adam Stein Isart Montane
2015-06-18 20:02:55 +00:00
# Baptiste M. Cole Turner Major Hayden
2016-08-30 11:34:52 +00:00
# Joe Ashcraft Jean-Marie Renouard Christian Loos
2008-09-08 01:16:39 +00:00
#
# Inspired by Matthew Montgomery's tuning-primer.sh script:
# http://forge.mysql.com/projects/view.php?id=44
#
2015-08-26 13:23:19 +00:00
package main ;
2015-11-23 07:14:28 +00:00
use 5.005 ;
2008-09-08 01:16:39 +00:00
use strict ;
use warnings ;
2015-11-23 07:14:28 +00:00
2008-09-08 01:16:39 +00:00
use diagnostics ;
2011-04-02 12:03:32 +00:00
use File::Spec ;
2008-09-08 01:16:39 +00:00
use Getopt::Long ;
2015-06-12 14:09:59 +00:00
use File::Basename ;
use Cwd 'abs_path' ;
2015-08-26 13:23:19 +00:00
2015-11-23 07:14:28 +00:00
use Data::Dumper ;
$ Data:: Dumper:: Pair = " : " ;
2016-04-18 14:45:34 +00:00
# for which()
2016-04-19 14:11:35 +00:00
#use Env;
2016-04-18 14:45:34 +00:00
2008-09-08 01:16:39 +00:00
# Set up a few variables for use in the script
2016-08-30 12:48:48 +00:00
my $ tunerversion = "1.6.18" ;
2015-08-19 12:45:24 +00:00
my ( @ adjvars , @ generalrec ) ;
2008-09-08 01:16:39 +00:00
# Set defaults
my % opt = (
2016-03-24 22:58:48 +00:00
"silent" = > 0 ,
"nobad" = > 0 ,
"nogood" = > 0 ,
"noinfo" = > 0 ,
"debug" = > 0 ,
"nocolor" = > 0 ,
"forcemem" = > 0 ,
"forceswap" = > 0 ,
"host" = > 0 ,
"socket" = > 0 ,
"port" = > 0 ,
"user" = > 0 ,
"pass" = > 0 ,
2016-08-30 11:34:52 +00:00
"password" = > 0 ,
2016-03-24 22:58:48 +00:00
"skipsize" = > 0 ,
"checkversion" = > 0 ,
"updateversion" = > 0 ,
"buffers" = > 0 ,
2016-03-29 12:22:45 +00:00
"passwordfile" = > 0 ,
2016-03-24 22:58:48 +00:00
"bannedports" = > '' ,
2016-03-29 12:22:45 +00:00
"maxportallowed" = > 0 ,
2016-03-24 22:58:48 +00:00
"outputfile" = > 0 ,
"dbstat" = > 0 ,
"idxstat" = > 0 ,
2016-03-30 15:16:16 +00:00
"sysstat" = > 0 ,
2016-03-24 22:58:48 +00:00
"skippassword" = > 0 ,
"noask" = > 0 ,
"template" = > 0 ,
"json" = > 0 ,
"prettyjson" = > 0 ,
"reportfile" = > 0 ,
"verbose" = > 0
2015-08-19 12:45:24 +00:00
) ;
2015-06-18 20:02:55 +00:00
2008-09-08 01:16:39 +00:00
# Gather the options from the command line
2016-03-24 22:58:48 +00:00
my $ getOptionsCheck = GetOptions (
2016-03-29 12:22:45 +00:00
\ % opt , 'nobad' ,
'nogood' , 'noinfo' ,
'debug' , 'nocolor' ,
'forcemem=i' , 'forceswap=i' ,
'host=s' , 'socket=s' ,
'port=i' , 'user=s' ,
'pass=s' , 'skipsize' ,
'checkversion' , 'mysqladmin=s' ,
'mysqlcmd=s' , 'help' ,
'buffers' , 'skippassword' ,
'passwordfile=s' , 'outputfile=s' ,
'silent' , 'dbstat' ,
'json' , 'prettyjson' ,
'idxstat' , 'noask' ,
'template=s' , 'reportfile=s' ,
'cvefile=s' , 'bannedports=s' ,
'updateversion' , 'maxportallowed=s' ,
2016-08-30 11:34:52 +00:00
'verbose' , 'sysstat' ,
'password=s' ,
2015-08-19 12:45:24 +00:00
) ;
2016-03-24 22:58:48 +00:00
#If params are incorrect return help
2016-03-29 12:22:45 +00:00
if ( $ getOptionsCheck ne 1 ) {
usage ( ) ;
2016-03-24 22:58:48 +00:00
}
2015-08-19 12:45:24 +00:00
if ( defined $ opt { 'help' } && $ opt { 'help' } == 1 ) { usage ( ) ; }
2008-09-08 01:16:39 +00:00
sub usage {
2015-08-19 12:45:24 +00:00
# Shown with --help option passed
print " MySQLTuner $tunerversion - MySQL High Performance Tuning Script\n"
. " Bug reports, feature requests, and downloads at http://mysqltuner.com/\n"
. " Maintained by Major Hayden (major\@mhtx.net) - Licensed under GPL\n"
. "\n"
. " Important Usage Guidelines:\n"
. " To run the script with the default options, run the script without arguments\n"
. " Allow MySQL server to run for at least 24-48 hours before trusting suggestions\n"
. " Some routines may require root level privileges (script will provide warnings)\n"
. " You must provide the remote server's total memory when connecting to other servers\n"
. "\n"
. " Connection and Authentication\n"
. " --host <hostname> Connect to a remote host to perform tests (default: localhost)\n"
. " --socket <socket> Use a different socket for a local connection\n"
. " --port <port> Port to use for connection (default: 3306)\n"
. " --user <username> Username to use for authentication\n"
. " --pass <password> Password to use for authentication\n"
. " --mysqladmin <path> Path to a custom mysqladmin executable\n"
. " --mysqlcmd <path> Path to a custom mysql executable\n" . "\n"
2016-04-22 15:22:00 +00:00
. " --noask Don't ask password if needed\n" . "\n"
2015-08-19 12:45:24 +00:00
. " Performance and Reporting Options\n"
. " --skipsize Don't enumerate tables and their types/sizes (default: on)\n"
. " (Recommended for servers with many tables)\n"
. " --skippassword Don't perform checks on user passwords(default: off)\n"
. " --checkversion Check for updates to MySQLTuner (default: don't check)\n"
2016-03-29 12:22:45 +00:00
. " --updateversion Check for updates to MySQLTuner and update when newer version is available (default: don't check)\n"
2015-08-19 12:45:24 +00:00
. " --forcemem <size> Amount of RAM installed in megabytes\n"
. " --forceswap <size> Amount of swap memory configured in megabytes\n"
. " --passwordfile <path>Path to a password file list(one password by line)\n"
. " Output Options:\n"
2015-08-26 13:23:19 +00:00
. " --silent Don't output anything on screen\n"
2015-08-19 12:45:24 +00:00
. " --nogood Remove OK responses\n"
. " --nobad Remove negative/suggestion responses\n"
. " --noinfo Remove informational responses\n"
. " --debug Print debug information\n"
. " --dbstat Print database information\n"
. " --idxstat Print index information\n"
2016-04-14 20:42:59 +00:00
. " --sysstat Print system information\n"
2016-03-29 12:22:45 +00:00
. " --bannedports Ports banned separated by comma(,)\n"
. " --maxportallowed Number of ports opened allowed on this hosts\n"
2016-01-05 23:57:34 +00:00
. " --cvefile CVE File for vulnerability checks\n"
2015-08-19 12:45:24 +00:00
. " --nocolor Don't print output in color\n"
2016-01-27 13:50:29 +00:00
. " --json Print result as JSON string\n"
2016-03-29 12:22:45 +00:00
. " --prettyjson Print result as human readable JSON\n"
2015-08-26 13:23:19 +00:00
. " --buffers Print global and per-thread buffer values\n"
. " --outputfile <path> Path to a output txt file\n" . "\n"
. " --reportfile <path> Path to a report txt file\n" . "\n"
2016-03-29 12:22:45 +00:00
. " --template <path> Path to a template file\n" . "\n"
. " --verbose Prints out all options (default: no verbose) \n"
. "\n" ;
2015-08-24 07:58:52 +00:00
exit 0 ;
2008-09-08 01:16:39 +00:00
}
2011-04-02 12:03:32 +00:00
my $ devnull = File::Spec - > devnull ( ) ;
2015-08-19 12:45:24 +00:00
my $ basic_password_files =
( $ opt { passwordfile } eq "0" )
? abs_path ( dirname ( __FILE__ ) ) . "/basic_passwords.txt"
: abs_path ( $ opt { passwordfile } ) ;
2015-06-15 07:47:24 +00:00
2016-08-30 11:34:52 +00:00
# Related to password option
$ opt { pass } = $ opt { password } if ( $ opt { pass } eq 0 and $ opt { password } ne 0 ) ;
2015-06-18 21:40:12 +00:00
# for RPM distributions
2015-08-19 12:45:24 +00:00
$ basic_password_files = "/usr/share/mysqltuner/basic_passwords.txt"
unless - f "$basic_password_files" ;
2015-06-18 21:40:12 +00:00
2016-03-24 22:58:48 +00:00
# check if we need to enable verbose mode
2016-03-29 12:22:45 +00:00
if ( $ opt { verbose } ) {
$ opt { checkversion } = 1 ; #Check for updates to MySQLTuner
$ opt { dbstat } = 1 ; #Print database information
$ opt { idxstat } = 1 ; #Print index information
2016-03-30 15:16:16 +00:00
$ opt { sysstat } = 1 ; #Print index information
2016-03-29 12:22:45 +00:00
$ opt { buffers } = 1 ; #Print global and per-thread buffer values
$ opt { cvefile } = 'vulnerabilities.csv' ; #CVE File for vulnerability checks
2016-03-24 22:58:48 +00:00
}
2016-01-06 00:17:05 +00:00
# for RPM distributions
2016-04-21 21:16:35 +00:00
$ opt { cvefile } = "/usr/share/mysqltuner/vulnerabilities.csv" unless ( defined $ opt { cvefile } and - f "$opt{cvefile}" ) ;
2016-03-29 12:22:45 +00:00
$ opt { cvefile } = '' unless - f "$opt{cvefile}" ;
$ opt { cvefile } = './vulnerabilities.csv' if - f './vulnerabilities.csv' ;
2016-01-06 00:17:05 +00:00
2016-03-29 12:22:45 +00:00
$ opt { 'bannedports' } = '' unless defined ( $ opt { 'bannedports' } ) ;
my @ banned_ports = split ',' , $ opt { 'bannedports' } ;
2016-01-06 00:17:05 +00:00
2015-08-19 12:45:24 +00:00
#
2015-08-26 13:23:19 +00:00
my $ outputfile = undef ;
$ outputfile = abs_path ( $ opt { outputfile } ) unless $ opt { outputfile } eq "0" ;
2015-06-16 21:38:17 +00:00
2015-08-19 12:45:24 +00:00
my $ fh = undef ;
2015-08-26 13:23:19 +00:00
open ( $ fh , '>' , $ outputfile )
or die ( "Fail opening $outputfile" )
if defined ( $ outputfile ) ;
$ opt { nocolor } = 1 if defined ( $ outputfile ) ;
2015-06-16 21:38:17 +00:00
2016-04-11 10:01:01 +00:00
# Setting up the colors for the print styles
2016-04-19 14:19:31 +00:00
my $ me = `whoami` ;
$ me =~ s/\n//g ;
2008-09-08 01:16:39 +00:00
# Setting up the colors for the print styles
2016-04-19 14:19:31 +00:00
my $ good = ( $ opt { nocolor } == 0 ) ? "[\e[0;32mOK\e[0m]" : "[OK]" ;
my $ bad = ( $ opt { nocolor } == 0 ) ? "[\e[0;31m!!\e[0m]" : "[!!]" ;
my $ info = ( $ opt { nocolor } == 0 ) ? "[\e[0;34m--\e[0m]" : "[--]" ;
my $ deb = ( $ opt { nocolor } == 0 ) ? "[\e[0;31mDG\e[0m]" : "[DG]" ;
my $ cmd = ( $ opt { nocolor } == 0 ) ? "\e[1;32m[CMD]($me)" : "[CMD]($me)" ;
my $ end = ( $ opt { nocolor } == 0 ) ? "\e[0m" : "" ;
2008-09-08 01:16:39 +00:00
2016-08-26 08:40:58 +00:00
# Checks for supported or EOL'ed MySQL versions
my ( $ mysqlvermajor , $ mysqlverminor , $ mysqlvermicro ) ;
2015-12-10 10:52:39 +00:00
# Super structure containing all information
2015-07-16 15:14:42 +00:00
my % result ;
2016-08-09 11:38:47 +00:00
$ result { 'MySQLTuner' } { 'version' } = $ tunerversion ;
2016-08-09 14:04:13 +00:00
$ result { 'MySQLTuner' } { 'options' } = \ % opt ;
2008-09-08 01:16:39 +00:00
# Functions that handle the print styles
2015-06-16 21:38:17 +00:00
sub prettyprint {
2016-03-29 12:22:45 +00:00
print $ _ [ 0 ] . "\n" unless ( $ opt { 'silent' } or $ opt { 'json' } ) ;
2015-08-19 12:45:24 +00:00
print $ fh $ _ [ 0 ] . "\n" if defined ( $ fh ) ;
}
sub goodprint { prettyprint $ good . " " . $ _ [ 0 ] unless ( $ opt { nogood } == 1 ) ; }
sub infoprint { prettyprint $ info . " " . $ _ [ 0 ] unless ( $ opt { noinfo } == 1 ) ; }
sub badprint { prettyprint $ bad . " " . $ _ [ 0 ] unless ( $ opt { nobad } == 1 ) ; }
sub debugprint { prettyprint $ deb . " " . $ _ [ 0 ] unless ( $ opt { debug } == 0 ) ; }
2016-03-29 12:22:45 +00:00
2015-08-19 12:45:24 +00:00
sub redwrap {
return ( $ opt { nocolor } == 0 ) ? "\e[0;31m" . $ _ [ 0 ] . "\e[0m" : $ _ [ 0 ] ;
}
sub greenwrap {
return ( $ opt { nocolor } == 0 ) ? "\e[0;32m" . $ _ [ 0 ] . "\e[0m" : $ _ [ 0 ] ;
2015-06-16 21:38:17 +00:00
}
2016-04-19 14:19:31 +00:00
sub cmdprint { prettyprint $ cmd . " " . $ _ [ 0 ] . $ end ; }
sub infoprintml {
for my $ ln ( @ _ ) { $ ln =~ s/\n//g ; infoprint "\t$ln" ; }
}
sub infoprintcmd {
cmdprint "@_" ;
infoprintml grep { $ _ ne '' and $ _ !~ /^\s*$/ } `@_ 2>&1` ;
}
2016-04-11 10:01:01 +00:00
sub subheaderprint {
2016-04-19 14:19:31 +00:00
my $ tln = 100 ;
my $ sln = 8 ;
my $ ln = length ( "@_" ) + 2 ;
2016-04-11 10:01:01 +00:00
2016-04-19 14:19:31 +00:00
prettyprint " " ;
prettyprint "-" x $ sln . " @_ " . "-" x ( $ tln - $ ln - $ sln ) ;
2016-04-11 10:01:01 +00:00
}
2016-04-19 14:19:31 +00:00
2016-04-11 10:01:01 +00:00
sub infoprinthcmd {
2016-04-19 14:19:31 +00:00
subheaderprint "$_[0]" ;
infoprintcmd "$_[1]" ;
2016-04-11 10:01:01 +00:00
}
2008-09-08 01:16:39 +00:00
2015-12-10 10:52:39 +00:00
# Calculates the parameter passed in bytes, then rounds it to one decimal place
2008-09-08 01:16:39 +00:00
sub hr_bytes {
2015-08-19 12:45:24 +00:00
my $ num = shift ;
if ( $ num >= ( 1024 ** 3 ) ) { #GB
return sprintf ( "%.1f" , ( $ num / ( 1024 ** 3 ) ) ) . "G" ;
}
elsif ( $ num >= ( 1024 ** 2 ) ) { #MB
return sprintf ( "%.1f" , ( $ num / ( 1024 ** 2 ) ) ) . "M" ;
}
elsif ( $ num >= 1024 ) { #KB
return sprintf ( "%.1f" , ( $ num / 1024 ) ) . "K" ;
}
else {
return $ num . "B" ;
}
2008-09-08 01:16:39 +00:00
}
2015-12-10 10:52:39 +00:00
# Calculates the parameter passed in bytes, then rounds it to the nearest integer
2008-09-08 01:16:39 +00:00
sub hr_bytes_rnd {
2015-08-19 12:45:24 +00:00
my $ num = shift ;
if ( $ num >= ( 1024 ** 3 ) ) { #GB
return int ( ( $ num / ( 1024 ** 3 ) ) ) . "G" ;
}
elsif ( $ num >= ( 1024 ** 2 ) ) { #MB
return int ( ( $ num / ( 1024 ** 2 ) ) ) . "M" ;
}
elsif ( $ num >= 1024 ) { #KB
return int ( ( $ num / 1024 ) ) . "K" ;
}
else {
return $ num . "B" ;
}
2008-09-08 01:16:39 +00:00
}
# Calculates the parameter passed to the nearest power of 1000, then rounds it to the nearest integer
sub hr_num {
2015-08-19 12:45:24 +00:00
my $ num = shift ;
if ( $ num >= ( 1000 ** 3 ) ) { # Billions
return int ( ( $ num / ( 1000 ** 3 ) ) ) . "B" ;
}
elsif ( $ num >= ( 1000 ** 2 ) ) { # Millions
return int ( ( $ num / ( 1000 ** 2 ) ) ) . "M" ;
}
elsif ( $ num >= 1000 ) { # Thousands
return int ( ( $ num / 1000 ) ) . "K" ;
}
else {
return $ num ;
}
2008-09-08 01:16:39 +00:00
}
2015-06-18 20:02:55 +00:00
# Calculate Percentage
2015-08-19 12:45:24 +00:00
sub percentage {
my $ value = shift ;
my $ total = shift ;
$ total = 0 unless defined $ total ;
return 100 , 00 if $ total == 0 ;
return sprintf ( "%.2f" , ( $ value * 100 / $ total ) ) ;
2015-06-18 20:02:55 +00:00
}
2008-09-08 01:16:39 +00:00
# Calculates uptime to display in a more attractive form
sub pretty_uptime {
2015-08-19 12:45:24 +00:00
my $ uptime = shift ;
my $ seconds = $ uptime % 60 ;
my $ minutes = int ( ( $ uptime % 3600 ) / 60 ) ;
my $ hours = int ( ( $ uptime % 86400 ) / ( 3600 ) ) ;
my $ days = int ( $ uptime / ( 86400 ) ) ;
my $ uptimestring ;
if ( $ days > 0 ) {
$ uptimestring = "${days}d ${hours}h ${minutes}m ${seconds}s" ;
}
elsif ( $ hours > 0 ) {
$ uptimestring = "${hours}h ${minutes}m ${seconds}s" ;
}
elsif ( $ minutes > 0 ) {
$ uptimestring = "${minutes}m ${seconds}s" ;
}
else {
$ uptimestring = "${seconds}s" ;
}
return $ uptimestring ;
2008-09-08 01:16:39 +00:00
}
# Retrieves the memory installed on this machine
2015-08-19 12:45:24 +00:00
my ( $ physical_memory , $ swap_memory , $ duflags ) ;
2016-08-30 11:16:33 +00:00
sub memerror {
badprint "Unable to determine total memory/swap; use '--forcemem' and '--forceswap'" ;
exit 1 ;
}
2016-03-29 12:22:45 +00:00
2016-08-30 11:16:33 +00:00
sub os_setup {
2015-08-19 12:45:24 +00:00
my $ os = `uname` ;
$ duflags = ( $ os =~ /Linux/ ) ? '-b' : '' ;
if ( $ opt { 'forcemem' } > 0 ) {
$ physical_memory = $ opt { 'forcemem' } * 1048576 ;
infoprint "Assuming $opt{'forcemem'} MB of physical memory" ;
if ( $ opt { 'forceswap' } > 0 ) {
$ swap_memory = $ opt { 'forceswap' } * 1048576 ;
infoprint "Assuming $opt{'forceswap'} MB of swap space" ;
}
else {
$ swap_memory = 0 ;
2016-03-29 12:22:45 +00:00
badprint "Assuming 0 MB of swap space (use --forceswap to specify)" ;
2015-08-19 12:45:24 +00:00
}
}
else {
2015-11-10 11:48:25 +00:00
if ( $ os =~ /Linux|CYGWIN/ ) {
2015-08-19 12:45:24 +00:00
$ physical_memory =
`grep -i memtotal: /proc/meminfo | awk '{print \$2}'`
or memerror ;
$ physical_memory *= 1024 ;
$ swap_memory =
`grep -i swaptotal: /proc/meminfo | awk '{print \$2}'`
or memerror ;
$ swap_memory *= 1024 ;
}
elsif ( $ os =~ /Darwin/ ) {
$ physical_memory = `sysctl -n hw.memsize` or memerror ;
$ swap_memory =
`sysctl -n vm.swapusage | awk '{print \$3}' | sed 's/\..*\$//'`
or memerror ;
}
elsif ( $ os =~ /NetBSD|OpenBSD|FreeBSD/ ) {
$ physical_memory = `sysctl -n hw.physmem` or memerror ;
if ( $ physical_memory < 0 ) {
$ physical_memory = `sysctl -n hw.physmem64` or memerror ;
}
$ swap_memory =
`swapctl -l | grep '^/' | awk '{ s+= \$2 } END { print s }'`
or memerror ;
}
elsif ( $ os =~ /BSD/ ) {
$ physical_memory = `sysctl -n hw.realmem` or memerror ;
$ swap_memory =
`swapinfo | grep '^/' | awk '{ s+= \$2 } END { print s }'` ;
}
elsif ( $ os =~ /SunOS/ ) {
$ physical_memory =
`/usr/sbin/prtconf | grep Memory | cut -f 3 -d ' '`
or memerror ;
chomp ( $ physical_memory ) ;
$ physical_memory = $ physical_memory * 1024 * 1024 ;
}
elsif ( $ os =~ /AIX/ ) {
$ physical_memory =
`lsattr -El sys0 | grep realmem | awk '{print \$2}'`
or memerror ;
chomp ( $ physical_memory ) ;
$ physical_memory = $ physical_memory * 1024 ;
$ swap_memory = `lsps -as | awk -F"(MB| +)" '/MB /{print \$2}'`
or memerror ;
chomp ( $ swap_memory ) ;
$ swap_memory = $ swap_memory * 1024 * 1024 ;
}
2016-03-29 12:22:45 +00:00
elsif ( $ os =~ /windows/i ) {
2016-02-16 15:29:47 +00:00
$ physical_memory =
2016-03-29 12:22:45 +00:00
`wmic ComputerSystem get TotalPhysicalMemory | perl -ne "chomp; print if /[0-9]+/;"`
2016-02-16 15:29:47 +00:00
or memerror ;
2016-03-29 12:22:45 +00:00
$ swap_memory =
`wmic OS get FreeVirtualMemory | perl -ne "chomp; print if /[0-9]+/;"`
2016-02-16 15:29:47 +00:00
or memerror ;
}
2015-08-19 12:45:24 +00:00
}
debugprint "Physical Memory: $physical_memory" ;
debugprint "Swap Memory: $swap_memory" ;
chomp ( $ physical_memory ) ;
chomp ( $ swap_memory ) ;
chomp ( $ os ) ;
$ result { 'OS' } { 'OS Type' } = $ os ;
$ result { 'OS' } { 'Physical Memory' } { 'bytes' } = $ physical_memory ;
$ result { 'OS' } { 'Physical Memory' } { 'pretty' } = hr_bytes ( $ physical_memory ) ;
$ result { 'OS' } { 'Swap Memory' } { 'bytes' } = $ swap_memory ;
$ result { 'OS' } { 'Swap Memory' } { 'pretty' } = hr_bytes ( $ swap_memory ) ;
2016-04-21 21:16:35 +00:00
$ result { 'OS' } { 'Other Processes' } { 'bytes' } = get_other_process_memory ( ) ;
$ result { 'OS' } { 'Other Processes' } { 'pretty' } = hr_bytes ( get_other_process_memory ( ) ) ;
2008-09-08 01:16:39 +00:00
}
2016-04-05 13:49:43 +00:00
sub get_http_cli {
2016-04-19 14:19:31 +00:00
my $ httpcli = which ( "curl" , $ ENV { 'PATH' } ) ;
2016-04-05 13:49:43 +00:00
chomp ( $ httpcli ) ;
2016-04-18 14:45:34 +00:00
if ( $ httpcli ) {
2016-04-19 14:19:31 +00:00
return $ httpcli ;
2016-04-05 13:49:43 +00:00
}
2016-04-19 14:19:31 +00:00
$ httpcli = which ( "wget" , $ ENV { 'PATH' } ) ;
2016-04-05 13:49:43 +00:00
chomp ( $ httpcli ) ;
2016-04-18 14:45:34 +00:00
if ( $ httpcli ) {
2016-04-19 14:19:31 +00:00
return $ httpcli ;
2016-04-05 13:49:43 +00:00
}
return "" ;
}
2016-04-18 14:45:34 +00:00
2015-08-25 14:15:54 +00:00
# Checks for updates to MySQLTuner
sub validate_tuner_version {
2016-03-29 12:22:45 +00:00
if ( $ opt { 'checkversion' } eq 0 and $ opt { 'updateversion' } eq 0 ) {
print "\n" unless ( $ opt { 'silent' } or $ opt { 'json' } ) ;
infoprint "Skipped version check for MySQLTuner script" ;
return ;
}
2015-11-23 07:08:25 +00:00
2016-03-29 12:22:45 +00:00
my $ update ;
my $ url =
"https://raw.githubusercontent.com/major/MySQLTuner-perl/master/mysqltuner.pl" ;
2016-04-18 14:45:34 +00:00
my $ httpcli = get_http_cli ( ) ;
if ( $ httpcli =~ /curl$/ ) {
2016-03-29 12:22:45 +00:00
debugprint "$httpcli is available." ;
2015-11-23 07:08:25 +00:00
2016-03-29 12:22:45 +00:00
debugprint
"$httpcli --connect-timeout 5 -silent '$url' 2>/dev/null | grep 'my \$tunerversion'| cut -d\\\" -f2" ;
$ update =
`$httpcli --connect-timeout 5 -silent '$url' 2>/dev/null | grep 'my \$tunerversion'| cut -d\\\" -f2` ;
chomp ( $ update ) ;
debugprint "VERSION: $update" ;
2015-11-23 07:08:25 +00:00
2016-03-29 12:22:45 +00:00
compare_tuner_version ( $ update ) ;
return ;
2016-04-19 14:19:31 +00:00
}
2015-11-23 07:08:25 +00:00
2016-04-19 14:19:31 +00:00
if ( $ httpcli =~ /wget$/ ) {
2016-03-29 12:22:45 +00:00
debugprint "$httpcli is available." ;
2015-11-23 07:08:25 +00:00
2016-03-29 12:22:45 +00:00
debugprint
"$httpcli -e timestamping=off -T 5 -O - '$url' 2>$devnull| grep 'my \$tunerversion'| cut -d\\\" -f2" ;
$ update =
`$httpcli -e timestamping=off -T 5 -O - '$url' 2>$devnull| grep 'my \$tunerversion'| cut -d\\\" -f2` ;
chomp ( $ update ) ;
compare_tuner_version ( $ update ) ;
return ;
}
debugprint "curl and wget are not available." ;
infoprint "Unable to check for the latest MySQLTuner version" ;
2016-02-20 16:07:19 +00:00
}
2015-08-25 14:15:54 +00:00
2016-03-24 22:58:48 +00:00
# Checks for updates to MySQLTuner
sub update_tuner_version {
2016-03-29 12:22:45 +00:00
if ( $ opt { 'updateversion' } eq 0 ) {
badprint "Skipped version update for MySQLTuner script" ;
print "\n" unless ( $ opt { 'silent' } or $ opt { 'json' } ) ;
return ;
}
2016-02-20 16:05:33 +00:00
2016-03-29 12:22:45 +00:00
#use Cwd;
my $ update ;
my $ url = "https://raw.githubusercontent.com/major/MySQLTuner-perl/master/" ;
my @ scripts =
( "mysqltuner.pl" , "basic_passwords.txt" , "vulnerabilities.csv" ) ;
my $ totalScripts = scalar ( @ scripts ) ;
my $ receivedScripts = 0 ;
2016-04-18 14:45:34 +00:00
my $ httpcli = get_http_cli ( ) ;
2016-03-29 12:22:45 +00:00
foreach my $ script ( @ scripts ) {
2016-03-24 22:58:48 +00:00
2016-04-18 14:45:34 +00:00
if ( $ httpcli =~ /curl$/ ) {
2016-03-29 12:22:45 +00:00
debugprint "$httpcli is available." ;
debugprint
2016-05-04 15:44:05 +00:00
"$httpcli --connect-timeout 5 '$url$script' 2>$devnull > $script" ;
2016-03-29 12:22:45 +00:00
$ update =
2016-05-04 15:44:05 +00:00
`$httpcli --connect-timeout 5 '$url$script' 2>$devnull > $script` ;
2016-03-29 12:22:45 +00:00
chomp ( $ update ) ;
debugprint "$script updated: $update" ;
if ( - s $ script eq 0 ) {
badprint "Couldn't update $script" ;
}
else {
+ + $ receivedScripts ;
debugprint "$script updated: $update" ;
}
2016-03-24 22:58:48 +00:00
}
2016-04-18 14:45:34 +00:00
elsif ( $ httpcli =~ /wget$/ ) {
2016-03-29 12:22:45 +00:00
2016-04-19 14:19:31 +00:00
debugprint "$httpcli is available." ;
debugprint
"$httpcli -qe timestamping=off -T 5 -O $script '$url$script'" ;
$ update =
`$httpcli -qe timestamping=off -T 5 -O $script '$url$script'` ;
chomp ( $ update ) ;
if ( - s $ script eq 0 ) {
badprint "Couldn't update $script" ;
}
else {
+ + $ receivedScripts ;
debugprint "$script updated: $update" ;
}
}
else {
debugprint "curl and wget are not available." ;
infoprint "Unable to check for the latest MySQLTuner version" ;
}
2016-03-24 22:58:48 +00:00
}
2016-03-29 12:22:45 +00:00
if ( $ receivedScripts eq $ totalScripts ) {
goodprint "Successfully updated MySQLTuner script" ;
}
else {
badprint "Couldn't update MySQLTuner script" ;
2016-03-24 22:58:48 +00:00
}
2016-03-29 12:22:45 +00:00
exit 0 ;
2016-02-20 16:07:19 +00:00
}
sub compare_tuner_version {
2016-03-29 12:22:45 +00:00
my $ remoteversion = shift ;
debugprint "Remote data: $remoteversion" ;
#exit 0;
if ( $ remoteversion ne $ tunerversion ) {
badprint
"There is a new version of MySQLTuner available ($remoteversion)" ;
update_tuner_version ( ) ;
return ;
}
goodprint "You have the latest version of MySQLTuner($tunerversion)" ;
2016-07-13 10:58:30 +00:00
return ;
2015-08-25 14:15:54 +00:00
}
2008-09-08 01:16:39 +00:00
# Checks to see if a MySQL login is possible
2015-08-19 12:45:24 +00:00
my ( $ mysqllogin , $ doremote , $ remotestring , $ mysqlcmd , $ mysqladmincmd ) ;
2015-11-12 22:55:14 +00:00
my $ osname = $^O ;
2016-03-29 12:22:45 +00:00
if ( $ osname eq 'MSWin32' ) {
eval { require Win32 ; } or last ;
$ osname = Win32:: GetOSName ( ) ;
infoprint "* Windows OS($osname) is not fully supported.\n" ;
#exit 1;
2015-11-12 22:55:14 +00:00
}
2016-03-29 12:22:45 +00:00
2008-09-08 01:16:39 +00:00
sub mysql_setup {
2015-08-19 12:45:24 +00:00
$ doremote = 0 ;
$ remotestring = '' ;
if ( $ opt { mysqladmin } ) {
$ mysqladmincmd = $ opt { mysqladmin } ;
}
else {
2016-04-19 14:19:31 +00:00
$ mysqladmincmd = which ( "mysqladmin" , $ ENV { 'PATH' } ) ;
2015-08-19 12:45:24 +00:00
}
chomp ( $ mysqladmincmd ) ;
if ( ! - e $ mysqladmincmd && $ opt { mysqladmin } ) {
badprint "Unable to find the mysqladmin command you specified: "
. $ mysqladmincmd . "" ;
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
elsif ( ! - e $ mysqladmincmd ) {
2016-03-29 12:22:45 +00:00
badprint "Couldn't find mysqladmin in your \$PATH. Is MySQL installed?" ;
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
if ( $ opt { mysqlcmd } ) {
$ mysqlcmd = $ opt { mysqlcmd } ;
}
else {
2016-04-19 14:19:31 +00:00
$ mysqlcmd = which ( "mysql" , $ ENV { 'PATH' } ) ;
2015-08-19 12:45:24 +00:00
}
chomp ( $ mysqlcmd ) ;
if ( ! - e $ mysqlcmd && $ opt { mysqlcmd } ) {
badprint "Unable to find the mysql command you specified: "
. $ mysqlcmd . "" ;
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
elsif ( ! - e $ mysqlcmd ) {
badprint "Couldn't find mysql in your \$PATH. Is MySQL installed?" ;
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
2015-08-24 08:32:56 +00:00
$ mysqlcmd =~ s/\n$//g ;
2016-03-29 12:22:45 +00:00
my $ mysqlclidefaults = `$mysqlcmd --print-defaults` ;
2015-08-25 12:07:13 +00:00
debugprint "MySQL Client: $mysqlclidefaults" ;
2016-03-29 12:22:45 +00:00
if ( $ mysqlclidefaults =~ /auto-vertical-output/ ) {
badprint
"Avoid auto-vertical-output in configuration file(s) for MySQL like" ;
exit 1 ;
2015-08-25 12:07:13 +00:00
}
2015-08-24 08:32:56 +00:00
debugprint "MySQL Client: $mysqlcmd" ;
2015-08-19 12:45:24 +00:00
# Are we being asked to connect via a socket?
if ( $ opt { socket } ne 0 ) {
$ remotestring = " -S $opt{socket}" ;
}
# Are we being asked to connect to a remote server?
if ( $ opt { host } ne 0 ) {
chomp ( $ opt { host } ) ;
$ opt { port } = ( $ opt { port } eq 0 ) ? 3306 : $ opt { port } ;
2016-03-29 12:22:45 +00:00
# If we're doing a remote connection, but forcemem wasn't specified, we need to exit
if ( $ opt { 'forcemem' } eq 0
&& ( $ opt { host } ne "127.0.0.1" )
&& ( $ opt { host } ne "localhost" ) )
{
badprint "The --forcemem option is required for remote connections" ;
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
infoprint "Performing tests on $opt{host}:$opt{port}" ;
$ remotestring = " -h $opt{host} -P $opt{port}" ;
2016-03-29 12:22:45 +00:00
if ( ( $ opt { host } ne "127.0.0.1" ) && ( $ opt { host } ne "localhost" ) ) {
$ doremote = 1 ;
2016-02-14 00:24:36 +00:00
}
2015-08-19 12:45:24 +00:00
}
2016-03-29 12:22:45 +00:00
2016-03-21 14:51:16 +00:00
# Did we already get a username without password on the command line?
if ( $ opt { user } ne 0 and $ opt { pass } eq 0 ) {
$ mysqllogin = "-u $opt{user} " . $ remotestring ;
my $ loginstatus = `$mysqladmincmd ping $mysqllogin 2>&1` ;
if ( $ loginstatus =~ /mysqld is alive/ ) {
2016-03-29 12:22:45 +00:00
goodprint "Logged in using credentials passed on the command line" ;
2016-03-21 14:51:16 +00:00
return 1 ;
}
else {
badprint
"Attempted to use login credentials, but they were invalid" ;
exit 1 ;
}
}
2016-03-29 12:22:45 +00:00
2015-08-19 12:45:24 +00:00
# Did we already get a username and password passed on the command line?
if ( $ opt { user } ne 0 and $ opt { pass } ne 0 ) {
2016-04-29 11:46:52 +00:00
$ mysqllogin = "-u $opt{user} -p'$opt{pass}'" . $ remotestring ;
2015-08-19 12:45:24 +00:00
my $ loginstatus = `$mysqladmincmd ping $mysqllogin 2>&1` ;
if ( $ loginstatus =~ /mysqld is alive/ ) {
2016-03-29 12:22:45 +00:00
goodprint "Logged in using credentials passed on the command line" ;
2015-08-19 12:45:24 +00:00
return 1 ;
}
else {
badprint
"Attempted to use login credentials, but they were invalid" ;
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
}
2016-04-19 14:19:31 +00:00
my $ svcprop = which ( "svcprop" , $ ENV { 'PATH' } ) ;
2015-08-19 12:45:24 +00:00
if ( substr ( $ svcprop , 0 , 1 ) =~ "/" ) {
# We are on solaris
( my $ mysql_login =
`svcprop -p quickbackup/username svc:/network/mysql-quickbackup:default`
) =~ s/\s+$// ;
( my $ mysql_pass =
`svcprop -p quickbackup/password svc:/network/mysql-quickbackup:default`
) =~ s/\s+$// ;
if ( substr ( $ mysql_login , 0 , 7 ) ne "svcprop" ) {
# mysql-quickbackup is installed
$ mysqllogin = "-u $mysql_login -p$mysql_pass" ;
my $ loginstatus = `mysqladmin $mysqllogin ping 2>&1` ;
if ( $ loginstatus =~ /mysqld is alive/ ) {
2016-03-29 12:22:45 +00:00
goodprint "Logged in using credentials from mysql-quickbackup." ;
2015-08-19 12:45:24 +00:00
return 1 ;
}
else {
badprint
"Attempted to use login credentials from mysql-quickbackup, but they failed." ;
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
}
}
elsif ( - r "/etc/psa/.psa.shadow" and $ doremote == 0 ) {
# It's a Plesk box, use the available credentials
$ mysqllogin = "-u admin -p`cat /etc/psa/.psa.shadow`" ;
my $ loginstatus = `$mysqladmincmd ping $mysqllogin 2>&1` ;
unless ( $ loginstatus =~ /mysqld is alive/ ) {
2016-03-29 12:22:45 +00:00
2016-03-23 15:18:36 +00:00
# Plesk 10+
2016-03-29 12:22:45 +00:00
$ mysqllogin =
"-u admin -p`/usr/local/psa/bin/admin --show-password`" ;
2016-03-23 15:18:36 +00:00
$ loginstatus = `$mysqladmincmd ping $mysqllogin 2>&1` ;
unless ( $ loginstatus =~ /mysqld is alive/ ) {
2016-03-29 12:22:45 +00:00
badprint
"Attempted to use login credentials from Plesk and Plesk 10+, but they failed." ;
exit 1 ;
2016-03-23 15:18:36 +00:00
}
2015-08-19 12:45:24 +00:00
}
}
elsif ( - r "/usr/local/directadmin/conf/mysql.conf" and $ doremote == 0 ) {
# It's a DirectAdmin box, use the available credentials
my $ mysqluser =
`cat /usr/local/directadmin/conf/mysql.conf | egrep '^user=.*'` ;
my $ mysqlpass =
`cat /usr/local/directadmin/conf/mysql.conf | egrep '^passwd=.*'` ;
$ mysqluser =~ s/user=// ;
$ mysqluser =~ s/[\r\n]// ;
$ mysqlpass =~ s/passwd=// ;
$ mysqlpass =~ s/[\r\n]// ;
$ mysqllogin = "-u $mysqluser -p$mysqlpass" ;
my $ loginstatus = `mysqladmin ping $mysqllogin 2>&1` ;
unless ( $ loginstatus =~ /mysqld is alive/ ) {
badprint
"Attempted to use login credentials from DirectAdmin, but they failed." ;
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
}
elsif ( - r "/etc/mysql/debian.cnf" and $ doremote == 0 ) {
# We have a debian maintenance account, use it
$ mysqllogin = "--defaults-file=/etc/mysql/debian.cnf" ;
my $ loginstatus = `$mysqladmincmd $mysqllogin ping 2>&1` ;
if ( $ loginstatus =~ /mysqld is alive/ ) {
goodprint
"Logged in using credentials from debian maintenance account." ;
return 1 ;
}
else {
badprint
"Attempted to use login credentials from debian maintenance account, but they failed." ;
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
}
else {
# It's not Plesk or debian, we should try a login
debugprint "$mysqladmincmd $remotestring ping 2>&1" ;
my $ loginstatus = `$mysqladmincmd $remotestring ping 2>&1` ;
if ( $ loginstatus =~ /mysqld is alive/ ) {
# Login went just fine
$ mysqllogin = " $remotestring " ;
2016-04-21 21:16:35 +00:00
# Did this go well because of a .my.cnf file or is there no password set?
2015-08-19 12:45:24 +00:00
my $ userpath = `printenv HOME` ;
if ( length ( $ userpath ) > 0 ) {
chomp ( $ userpath ) ;
}
unless ( - e "${userpath}/.my.cnf" or - e "${userpath}/.mylogin.cnf" )
{
2016-04-21 21:16:35 +00:00
badprint "Successfully authenticated with no password - SECURITY RISK!" ;
2015-08-19 12:45:24 +00:00
}
return 1 ;
}
else {
2016-03-29 12:22:45 +00:00
if ( $ opt { 'noask' } == 1 ) {
badprint
"Attempted to use login credentials, but they were invalid" ;
2015-08-24 07:58:52 +00:00
exit 1 ;
}
2016-03-29 12:22:45 +00:00
my ( $ name , $ password ) ;
2016-02-14 00:24:36 +00:00
# If --user is defined no need to ask for username
2016-03-29 12:22:45 +00:00
if ( $ opt { user } ne 0 ) {
2016-02-14 00:24:36 +00:00
$ name = $ opt { user } ;
}
2016-03-29 12:22:45 +00:00
else {
2016-02-14 00:24:36 +00:00
print STDERR "Please enter your MySQL administrative login: " ;
$ name = <STDIN> ;
}
2016-03-29 12:22:45 +00:00
2016-02-14 00:24:36 +00:00
# If --pass is defined no need to ask for password
2016-03-29 12:22:45 +00:00
if ( $ opt { pass } ne 0 ) {
2016-02-14 00:24:36 +00:00
$ password = $ opt { pass } ;
}
2016-03-29 12:22:45 +00:00
else {
print STDERR
"Please enter your MySQL administrative password: " ;
2016-02-14 00:24:36 +00:00
system ( "stty -echo >$devnull 2>&1" ) ;
$ password = <STDIN> ;
system ( "stty echo >$devnull 2>&1" ) ;
}
2015-08-19 12:45:24 +00:00
chomp ( $ password ) ;
chomp ( $ name ) ;
$ mysqllogin = "-u $name" ;
if ( length ( $ password ) > 0 ) {
2016-02-20 16:01:30 +00:00
$ mysqllogin . = " -p\"$password\"" ;
2015-08-19 12:45:24 +00:00
}
$ mysqllogin . = $ remotestring ;
my $ loginstatus = `$mysqladmincmd ping $mysqllogin 2>&1` ;
if ( $ loginstatus =~ /mysqld is alive/ ) {
print STDERR "" ;
if ( ! length ( $ password ) ) {
# Did this go well because of a .my.cnf file or is there no password set?
2016-02-20 16:01:30 +00:00
my $ userpath = `printenv HOME` ;
2015-08-19 12:45:24 +00:00
chomp ( $ userpath ) ;
unless ( - e "$userpath/.my.cnf" ) {
badprint
"Successfully authenticated with no password - SECURITY RISK!" ;
}
}
return 1 ;
}
else {
2016-03-29 12:22:45 +00:00
badprint
"Attempted to use login credentials, but they were invalid." ;
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
2015-08-24 08:00:10 +00:00
exit 1 ;
2015-08-19 12:45:24 +00:00
}
}
2008-09-08 01:16:39 +00:00
}
2015-07-02 20:06:43 +00:00
# MySQL Request Array
sub select_array {
2015-08-19 12:45:24 +00:00
my $ req = shift ;
debugprint "PERFORM: $req " ;
2016-01-27 16:22:49 +00:00
my @ result = `$mysqlcmd $mysqllogin -Bse "$req" 2>>/dev/null` ;
2016-03-29 12:22:45 +00:00
if ( $? != 0 ) {
badprint "failed to execute: $req" ;
badprint "FAIL Execute SQL / return code: $?" ;
debugprint "CMD : $mysqlcmd" ;
debugprint "OPTIONS: $mysqllogin" ;
debugprint `$mysqlcmd $mysqllogin -Bse "$req" 2>&1` ;
#exit $?;
}
debugprint "select_array: return code : $?" ;
2015-08-19 12:45:24 +00:00
chomp ( @ result ) ;
return @ result ;
2015-07-02 20:06:43 +00:00
}
# MySQL Request one
sub select_one {
2015-08-19 12:45:24 +00:00
my $ req = shift ;
debugprint "PERFORM: $req " ;
2016-01-27 16:22:49 +00:00
my $ result = `$mysqlcmd $mysqllogin -Bse "$req" 2>>/dev/null` ;
2016-03-29 12:22:45 +00:00
if ( $? != 0 ) {
badprint "failed to execute: $req" ;
badprint "FAIL Execute SQL / return code: $?" ;
debugprint "CMD : $mysqlcmd" ;
debugprint "OPTIONS: $mysqllogin" ;
debugprint `$mysqlcmd $mysqllogin -Bse "$req" 2>&1` ;
#exit $?;
}
2016-04-11 10:24:49 +00:00
debugprint "select_array: return code : $?" ;
2015-08-19 12:45:24 +00:00
chomp ( $ result ) ;
return $ result ;
2015-07-02 20:06:43 +00:00
}
2015-07-16 15:14:42 +00:00
sub get_tuning_info {
2015-08-19 12:45:24 +00:00
my @ infoconn = select_array "\\s" ;
my ( $ tkey , $ tval ) ;
@ infoconn =
grep { ! /Threads:/ and ! /Connection id:/ and ! /pager:/ and ! /Using/ }
@ infoconn ;
foreach my $ line ( @ infoconn ) {
if ( $ line =~ /\s*(.*):\s*(.*)/ ) {
debugprint "$1 => $2" ;
$ tkey = $ 1 ;
$ tval = $ 2 ;
chomp ( $ tkey ) ;
chomp ( $ tval ) ;
$ result { 'MySQL Client' } { $ tkey } = $ tval ;
}
}
$ result { 'MySQL Client' } { 'Client Path' } = $ mysqlcmd ;
$ result { 'MySQL Client' } { 'Admin Path' } = $ mysqladmincmd ;
$ result { 'MySQL Client' } { 'Authentication Info' } = $ mysqllogin ;
2015-07-16 15:14:42 +00:00
}
2015-08-19 12:45:24 +00:00
2008-09-08 01:16:39 +00:00
# Populates all of the variable and status hashes
2015-08-19 12:45:24 +00:00
my ( % mystat , % myvar , $ dummyselect , % myrepl , % myslaves ) ;
2016-04-14 20:42:59 +00:00
sub arr2hash {
2016-04-19 14:19:31 +00:00
my $ href = shift ;
my $ harr = shift ;
my $ sep = shift ;
$ sep = '\s' unless defined ( $ sep ) ;
foreach my $ line ( @$ harr ) {
2016-06-02 07:23:46 +00:00
next if ( $ line =~ m/^\*\*\*\*\*\*\*/ ) ;
2016-04-14 20:42:59 +00:00
$ line =~ /([a-zA-Z_]*)\s*$sep\s*(.*)/ ;
$$ href { $ 1 } = $ 2 ;
debugprint "V: $1 = $2" ;
2016-04-19 14:19:31 +00:00
}
2016-04-14 20:42:59 +00:00
}
2015-08-19 12:45:24 +00:00
2016-04-14 20:42:59 +00:00
sub get_all_vars {
2015-08-19 12:45:24 +00:00
# We need to initiate at least one query so that our data is useable
$ dummyselect = select_one "SELECT VERSION()" ;
2016-08-09 11:38:47 +00:00
if ( not defined ( $ dummyselect ) or $ dummyselect eq "" ) {
2016-08-09 08:15:49 +00:00
badprint "You probably doesn't get enough privileges for running MySQLTuner ..." ;
2016-08-08 15:40:53 +00:00
exit ( 256 ) ;
}
2016-06-23 19:30:22 +00:00
$ dummyselect =~ s/(.*?)\-.*/$1/ ;
2015-08-19 12:45:24 +00:00
debugprint "VERSION: " . $ dummyselect . "" ;
$ result { 'MySQL Client' } { 'Version' } = $ dummyselect ;
2016-04-19 14:19:31 +00:00
2016-04-29 10:56:24 +00:00
my @ mysqlvarlist = select_array ( "SHOW VARIABLES" ) ;
push ( @ mysqlvarlist , select_array ( "SHOW GLOBAL VARIABLES" ) ) ;
2016-04-19 14:19:31 +00:00
arr2hash ( \ % myvar , \ @ mysqlvarlist ) ;
2016-06-02 07:23:46 +00:00
$ result { 'Variables' } = \ % myvar ;
2016-04-19 14:19:31 +00:00
2016-04-29 10:56:24 +00:00
my @ mysqlstatlist = select_array ( "SHOW STATUS" ) ;
push ( @ mysqlstatlist , select_array ( "SHOW GLOBAL STATUS" ) ) ;
2016-04-19 14:19:31 +00:00
arr2hash ( \ % mystat , \ @ mysqlstatlist ) ;
2016-06-02 07:23:46 +00:00
$ result { 'Status' } = \ % mystat ;
2016-04-19 14:19:31 +00:00
2016-04-04 15:23:43 +00:00
$ myvar { 'have_galera' } = "NO" ;
2016-04-19 14:19:31 +00:00
if ( defined ( $ myvar { 'wsrep_provider_options' } )
&& $ myvar { 'wsrep_provider_options' } ne "" )
{
2016-04-04 15:23:43 +00:00
$ myvar { 'have_galera' } = "YES" ;
2016-04-19 14:19:31 +00:00
debugprint "Galera options: " . $ myvar { 'wsrep_provider_options' } ;
2016-04-04 15:23:43 +00:00
}
2016-04-14 20:49:21 +00:00
2015-08-19 12:45:24 +00:00
# Workaround for MySQL bug #59393 wrt. ignore-builtin-innodb
if ( ( $ myvar { 'ignore_builtin_innodb' } || "" ) eq "ON" ) {
$ myvar { 'have_innodb' } = "NO" ;
}
2016-03-29 12:22:45 +00:00
2016-03-22 14:20:18 +00:00
$ myvar { 'have_threadpool' } = "NO" ;
2016-03-29 12:22:45 +00:00
if ( defined ( $ myvar { 'thread_pool_size' } )
and $ myvar { 'thread_pool_size' } > 0 )
{
2016-03-22 14:20:18 +00:00
$ myvar { 'have_threadpool' } = "YES" ;
}
2016-03-29 12:22:45 +00:00
2015-08-19 12:45:24 +00:00
# have_* for engines is deprecated and will be removed in MySQL 5.6;
# check SHOW ENGINES and set corresponding old style variables.
# Also works around MySQL bug #59393 wrt. skip-innodb
my @ mysqlenginelist = select_array "SHOW ENGINES" ;
foreach my $ line ( @ mysqlenginelist ) {
if ( $ line =~ /^([a-zA-Z_]+)\s+(\S+)/ ) {
my $ engine = lc ( $ 1 ) ;
if ( $ engine eq "federated" || $ engine eq "blackhole" ) {
$ engine . = "_engine" ;
}
elsif ( $ engine eq "berkeleydb" ) {
$ engine = "bdb" ;
}
my $ val = ( $ 2 eq "DEFAULT" ) ? "YES" : $ 2 ;
$ myvar { "have_$engine" } = $ val ;
$ result { 'Storage Engines' } { $ engine } = $ 2 ;
}
}
2016-04-05 16:25:20 +00:00
debugprint Dumper ( @ mysqlenginelist ) ;
2016-04-14 20:42:59 +00:00
my @ mysqlslave = select_array ( "SHOW SLAVE STATUS\\G" ) ;
2016-04-19 14:19:31 +00:00
arr2hash ( \ % myrepl , \ @ mysqlslave , ':' ) ;
2016-06-02 07:23:46 +00:00
$ result { 'Replication' } { 'Status' } = \ % myrepl ;
2015-08-19 12:45:24 +00:00
my @ mysqlslaves = select_array "SHOW SLAVE HOSTS" ;
my @ lineitems = ( ) ;
foreach my $ line ( @ mysqlslaves ) {
debugprint "L: $line " ;
@ lineitems = split /\s+/ , $ line ;
$ myslaves { $ lineitems [ 0 ] } = $ line ;
$ result { 'Replication' } { 'Slaves' } { $ lineitems [ 0 ] } = $ lineitems [ 4 ] ;
}
2008-09-08 01:16:39 +00:00
}
2016-03-22 13:44:01 +00:00
sub remove_cr {
map { s/\n$//g ; } @ _ ;
2016-04-04 15:23:43 +00:00
map { s/^\s+$//g ; } @ _ ;
2016-03-22 13:44:01 +00:00
}
2016-03-29 12:22:45 +00:00
2016-03-22 13:44:01 +00:00
sub remove_empty {
grep { $ _ ne '' } @ _ ;
}
2016-03-29 12:22:45 +00:00
2016-03-22 13:44:01 +00:00
sub get_file_contents {
2015-08-19 12:45:24 +00:00
my $ file = shift ;
2016-08-30 11:27:13 +00:00
open ( my $ fh , "<" , $ file ) or die "Can't open $file for read: $!" ;
my @ lines = <$fh> ;
close $ fh or die "Cannot close $file: $!" ;
2016-03-22 13:44:01 +00:00
remove_cr \ @ lines ;
2015-08-19 12:45:24 +00:00
return @ lines ;
2015-06-12 14:09:59 +00:00
}
2016-03-22 13:44:01 +00:00
sub get_basic_passwords {
return get_file_contents ( shift ) ;
}
2016-01-05 23:57:34 +00:00
sub cve_recommendations {
2016-04-19 14:19:31 +00:00
subheaderprint "CVE Security Recommendations" ;
2016-03-29 12:22:45 +00:00
unless ( defined ( $ opt { cvefile } ) && - f "$opt{cvefile}" ) {
2016-01-06 00:17:05 +00:00
infoprint "Skipped due to --cvefile option undefined" ;
2016-01-05 23:57:34 +00:00
return ;
}
2016-04-21 21:16:35 +00:00
#prettyprint "Look for related CVE for $myvar{'version'} or lower in $opt{cvefile}";
2016-03-29 12:22:45 +00:00
my $ cvefound = 0 ;
2016-08-30 11:27:13 +00:00
open ( my $ fh , "<" , $ opt { cvefile } ) or die "Can't open $opt{cvefile} for read: $!" ;
while ( my $ cveline = <$fh> ) {
2016-03-29 12:22:45 +00:00
my @ cve = split ( ';' , $ cveline ) ;
2016-08-26 08:40:58 +00:00
debugprint "Comparing $mysqlvermajor\.$mysqlverminor\.$mysqlvermicro with $cve[1]\.$cve[2]\.$cve[3] : " . ( mysql_version_le ( $ cve [ 1 ] , $ cve [ 2 ] , $ cve [ 3 ] ) ? '<=' : '>' ) ;
2016-08-29 15:10:26 +00:00
# Avoid not major/minor version corresponding CVEs
next unless ( int ( $ cve [ 1 ] ) == $ mysqlvermajor && int ( $ cve [ 2 ] ) == $ mysqlverminor ) ;
if ( int ( $ cve [ 3 ] ) >= $ mysqlvermicro ) {
badprint "$cve[4](<= $cve[1]\.$cve[2]\.$cve[3]) : $cve[6]" ;
$ result { 'CVE' } { 'List' } { $ cvefound } = "$cve[4](<= $cve[1]\.$cve[2]\.$cve[3]) : $cve[6]" ;
2016-03-29 12:22:45 +00:00
$ cvefound + + ;
}
2016-01-05 23:57:34 +00:00
}
2016-08-30 11:27:13 +00:00
close $ fh or die "Cannot close $opt{cvefile}: $!" ;
2016-04-21 21:16:35 +00:00
$ result { 'CVE' } { 'nb' } = $ cvefound ;
2016-03-29 12:22:45 +00:00
if ( $ cvefound == 0 ) {
goodprint "NO SECURITY CVE FOUND FOR YOUR VERSION" ;
return ;
}
2016-01-05 23:57:34 +00:00
badprint $ cvefound . " CVE(s) found for your MySQL release." ;
2016-03-29 12:22:45 +00:00
push ( @ generalrec ,
$ cvefound
. " CVE(s) found for your MySQL release. Consider upgrading your version !"
) ;
2016-01-05 23:57:34 +00:00
}
2016-03-21 16:11:20 +00:00
sub get_opened_ports {
2016-03-29 12:22:45 +00:00
my @ opened_ports = `netstat -ltn` ;
map {
s/.*:(\d+)\s.*$/$1/ ;
s/\D//g ;
} @ opened_ports ;
@ opened_ports = sort { $ a <=> $ b } grep { ! /^$/ } @ opened_ports ;
debugprint Dumper \ @ opened_ports ;
2016-08-09 14:04:13 +00:00
$ result { 'Network' } { 'TCP Opened' } = \ @ opened_ports ;
2016-03-29 12:22:45 +00:00
return @ opened_ports ;
2016-03-21 16:11:20 +00:00
}
sub is_open_port {
2016-03-29 12:22:45 +00:00
my $ port = shift ;
if ( grep { /^$port$/ } get_opened_ports ) {
return 1 ;
}
return 0 ;
2016-03-21 16:11:20 +00:00
}
2016-03-22 13:44:01 +00:00
sub get_process_memory {
2016-03-29 12:22:45 +00:00
my $ pid = shift ;
2016-05-10 09:34:30 +00:00
my @ mem = `ps -p $pid -o rss` ;
return 0 if scalar @ mem != 2 ;
return $ mem [ 1 ] * 1024 ;
2016-03-22 13:44:01 +00:00
}
sub get_other_process_memory {
2016-05-19 15:06:12 +00:00
my @ procs = `ps eaxo pid,command` ;
2016-03-29 12:22:45 +00:00
map {
2016-05-10 09:34:30 +00:00
s/.*PID.*// ;
2016-03-29 12:22:45 +00:00
s/.*mysqld.*// ;
s/.*\[.*\].*// ;
s/^\s+$//g ;
s/.*PID.*CMD.*// ;
s/.*systemd.*// ;
} @ procs ;
map { s/\s*?(\d+)\s*.*/$1/g ; } @ procs ;
remove_cr @ procs ;
@ procs = remove_empty @ procs ;
my $ totalMemOther = 0 ;
map { $ totalMemOther += get_process_memory ( $ _ ) ; } @ procs ;
return $ totalMemOther ;
2016-03-22 13:44:01 +00:00
}
sub get_os_release {
2016-04-19 14:19:31 +00:00
if ( - f "/etc/lsb-release" ) {
2016-04-13 13:39:40 +00:00
my @ info_release = get_file_contents "/etc/lsb-release" ;
remove_cr @ info_release ;
my $ os_relase = $ info_release [ 3 ] ;
$ os_relase =~ s/.*="// ;
$ os_relase =~ s/"$// ;
return $ os_relase ;
2016-04-19 14:19:31 +00:00
}
2016-04-13 13:39:40 +00:00
2016-04-19 14:19:31 +00:00
if ( - f "/etc/system-release" ) {
2016-03-30 11:44:30 +00:00
my @ info_release = get_file_contents "/etc/system-release" ;
remove_cr @ info_release ;
return $ info_release [ 0 ] ;
2016-04-19 14:19:31 +00:00
}
2016-03-30 11:44:30 +00:00
2016-04-19 14:19:31 +00:00
if ( - f "/etc/os-release" ) {
2016-03-30 11:44:30 +00:00
my @ info_release = get_file_contents "/etc/os-release" ;
remove_cr @ info_release ;
my $ os_relase = $ info_release [ 0 ] ;
$ os_relase =~ s/.*="// ;
$ os_relase =~ s/"$// ;
return $ os_relase ;
2016-04-19 14:19:31 +00:00
}
2016-03-30 11:44:30 +00:00
2016-04-19 14:19:31 +00:00
if ( - f "/etc/issue" ) {
2016-03-30 11:44:30 +00:00
my @ info_release = get_file_contents "/etc/issue" ;
remove_cr @ info_release ;
my $ os_relase = $ info_release [ 0 ] ;
$ os_relase =~ s/\s+\\n.*// ;
return $ os_relase ;
2016-04-19 14:19:31 +00:00
}
2016-03-30 11:44:30 +00:00
return "Unknown OS release" ;
2016-03-22 13:44:01 +00:00
}
2016-03-25 13:32:15 +00:00
sub get_fs_info () {
2016-03-29 12:22:45 +00:00
my @ sinfo = `df -P | grep '%'` ;
my @ iinfo = `df -Pi| grep '%'` ;
2016-03-25 13:32:15 +00:00
shift @ iinfo ;
2016-03-29 12:22:45 +00:00
map { s/.*\s(\d+)%\s+(.*)/$1\t$2/g } @ sinfo ;
2016-03-25 13:32:15 +00:00
foreach my $ info ( @ sinfo ) {
2016-03-30 12:59:47 +00:00
next if $ info =~ m {(\d+)\t/(run|dev|sys|proc)($|/)} ;
2016-03-29 12:22:45 +00:00
if ( $ info =~ /(\d+)\t(.*)/ ) {
if ( $ 1 > 85 ) {
badprint "mount point $2 is using $1 % total space" ;
push ( @ generalrec , "Add some space to $2 mountpoint." ) ;
}
else {
infoprint "mount point $2 is using $1 % of total space" ;
}
2016-08-09 14:04:13 +00:00
$ result { 'Filesystem' } { 'Space Pct' } { $ 2 } = $ 1 ;
2016-03-29 12:22:45 +00:00
}
}
2016-03-22 13:44:01 +00:00
2016-03-29 12:22:45 +00:00
map { s/.*\s(\d+)%\s+(.*)/$1\t$2/g } @ iinfo ;
2016-03-25 13:32:15 +00:00
foreach my $ info ( @ iinfo ) {
2016-03-30 12:59:47 +00:00
next if $ info =~ m {(\d+)\t/(run|dev|sys|proc)($|/)} ;
2016-03-29 12:22:45 +00:00
if ( $ info =~ /(\d+)\t(.*)/ ) {
if ( $ 1 > 85 ) {
badprint "mount point $2 is using $1 % of max allowed inodes" ;
push ( @ generalrec ,
"Cleanup files from $2 mountpoint or reformat you filesystem."
) ;
}
else {
infoprint "mount point $2 is using $1 % of max allowed inodes" ;
}
2016-08-09 14:04:13 +00:00
$ result { 'Filesystem' } { 'Inode Pct' } { $ 2 } = $ 1 ;
2016-03-29 12:22:45 +00:00
}
2016-03-22 13:44:01 +00:00
}
2016-03-25 13:32:15 +00:00
}
2016-03-22 13:44:01 +00:00
2016-04-19 14:19:31 +00:00
sub merge_hash {
my $ h1 = shift ;
my $ h2 = shift ;
my % result = { } ;
foreach my $ substanceref ( $ h1 , $ h2 ) {
while ( my ( $ k , $ v ) = each %$ substanceref ) {
next if ( exists $ result { $ k } ) ;
$ result { $ k } = $ v ;
}
2016-04-14 20:42:59 +00:00
}
2016-04-19 14:19:31 +00:00
return \ % result ;
2016-04-14 20:42:59 +00:00
}
2016-03-29 12:22:45 +00:00
2016-03-25 15:22:07 +00:00
sub is_virtual_machine () {
2016-03-29 12:22:45 +00:00
my $ isVm = `grep -Ec '^flags.*\ hypervisor\ ' /proc/cpuinfo` ;
return ( $ isVm == 0 ? 0 : 1 ) ;
2016-03-25 15:22:07 +00:00
}
2016-03-21 16:11:20 +00:00
2016-03-25 15:22:07 +00:00
sub infocmd {
2016-03-29 12:22:45 +00:00
my $ cmd = "@_" ;
debugprint "CMD: $cmd" ;
my @ result = `$cmd` ;
remove_cr @ result ;
for my $ l ( @ result ) {
infoprint "$l" ;
}
2016-03-25 15:22:07 +00:00
}
2016-03-29 12:22:45 +00:00
2016-03-25 15:22:07 +00:00
sub infocmd_tab {
2016-03-29 12:22:45 +00:00
my $ cmd = "@_" ;
debugprint "CMD: $cmd" ;
my @ result = `$cmd` ;
remove_cr @ result ;
for my $ l ( @ result ) {
infoprint "\t$l" ;
2016-03-21 16:11:20 +00:00
}
2016-03-25 15:22:07 +00:00
}
2016-03-29 12:22:45 +00:00
2016-03-25 15:22:07 +00:00
sub infocmd_one {
2016-03-29 12:22:45 +00:00
my $ cmd = "@_" ;
my @ result = `$cmd` ;
remove_cr @ result ;
return join ', ' , @ result ;
}
2016-04-19 14:19:31 +00:00
sub get_kernel_info () {
my @ params = (
'fs.aio-max-nr' , 'fs.aio-nr' ,
'fs.file-max' , 'sunrpc.tcp_fin_timeout' ,
'sunrpc.tcp_max_slot_table_entries' , 'sunrpc.tcp_slot_table_entries' ,
'vm.swappiness'
) ;
2016-04-22 15:22:00 +00:00
infoprint "Information about kernel tuning:" ;
2016-04-19 14:19:31 +00:00
foreach my $ param ( @ params ) {
2016-08-09 11:38:47 +00:00
infocmd_tab ( "sysctl $param 2>/dev/null" ) ;
2016-08-09 14:04:13 +00:00
$ result { 'OS' } { 'Config' } { $ param } = `sysctl -n $param 2>/dev/null` ;
2016-04-19 14:19:31 +00:00
}
if ( `sysctl -n vm.swappiness` > 10 ) {
badprint
"Swappiness is > 10, please consider having a value lower than 10" ;
push @ generalrec , "setup swappiness lower or equals to 10" ;
push @ adjvars , 'vm.swappiness <= 10 (echo 0 > /proc/sys/vm/swappiness)' ;
}
else {
infoprint "Swappiness is < 10." ;
}
2016-08-10 09:48:41 +00:00
# only if /proc/sys/sunrpc exists
2016-08-09 11:38:47 +00:00
my $ tcp_slot_entries = `sysctl -n sunrpc.tcp_slot_table_entries 2>/dev/null` ;
2016-08-26 08:40:58 +00:00
if ( - f "/proc/sys/sunrpc" and ( $ tcp_slot_entries eq '' or $ tcp_slot_entries < 100 ) ) {
2016-04-19 14:19:31 +00:00
badprint
"Initial TCP slot entries is < 1M, please consider having a value greater than 100" ;
push @ generalrec , "setup Initial TCP slot entries greater than 100" ;
push @ adjvars ,
'sunrpc.tcp_slot_table_entries > 100 (echo 128 > /proc/sys/sunrpc/tcp_slot_table_entries)' ;
}
else {
infoprint "TCP slot entries is > 100." ;
}
if ( `sysctl -n fs.aio-max-nr` < 1000000 ) {
badprint
"Max running total of the number of events is < 1M, please consider having a value greater than 1M" ;
push @ generalrec , "setup Max running number events greater than 1M" ;
push @ adjvars ,
'fs.aio-max-nr > 1M (echo 1048576 > /proc/sys/fs/aio-max-nr)' ;
}
else {
infoprint "Max Number of AIO events is > 1M." ;
}
}
2016-03-21 16:11:20 +00:00
2016-03-29 12:22:45 +00:00
sub get_system_info () {
2016-08-09 14:04:13 +00:00
$ result { 'OS' } { 'Release' } = get_os_release ( ) ;
2016-03-29 12:22:45 +00:00
infoprint get_os_release ;
if ( is_virtual_machine ) {
infoprint "Machine type : Virtual machine" ;
2016-08-09 14:04:13 +00:00
$ result { 'OS' } { 'Virtual Machine' } = 'YES' ;
2016-03-21 16:11:20 +00:00
}
2016-03-29 12:22:45 +00:00
else {
infoprint "Machine type : Physical machine" ;
2016-08-09 14:04:13 +00:00
$ result { 'OS' } { 'Virtual Machine' } = 'NO' ;
2016-03-29 12:22:45 +00:00
}
2016-08-09 14:04:13 +00:00
$ result { 'Network' } { 'Connected' } = 'NO' ;
2016-04-05 13:49:43 +00:00
`ping -c 1 ipecho.net &>/dev/null` ;
2016-03-29 12:22:45 +00:00
my $ isConnected = $? ;
if ( $? == 0 ) {
infoprint "Internet : Connected" ;
2016-08-09 14:04:13 +00:00
$ result { 'Network' } { 'Connected' } = 'YES' ;
2016-03-21 16:11:20 +00:00
}
2016-03-29 12:22:45 +00:00
else {
badprint "Internet : Disconnected" ;
}
2016-08-09 14:04:13 +00:00
$ result { 'OS' } { 'Type' } = `uname -o` ;
2016-03-29 12:22:45 +00:00
infoprint "Operating System Type : " . infocmd_one "uname -o" ;
2016-08-09 14:04:13 +00:00
$ result { 'OS' } { 'Kernel' } = `uname -r` ;
2016-03-29 12:22:45 +00:00
infoprint "Kernel Release : " . infocmd_one "uname -r" ;
2016-08-09 14:04:13 +00:00
$ result { 'OS' } { 'Hostname' } = `hostname` ;
$ result { 'Network' } { 'Internal Ip' } = `hostname -I` ;
2016-03-29 12:22:45 +00:00
infoprint "Hostname : " . infocmd_one "hostname" ;
infoprint "Network Cards : " ;
infocmd_tab "ifconfig| grep -A1 mtu" ;
infoprint "Internal IP : " . infocmd_one "hostname -I" ;
2016-04-19 14:19:31 +00:00
my $ httpcli = get_http_cli ( ) ;
2016-04-05 13:49:43 +00:00
infoprint "HTTP client found: $httpcli" if defined $ httpcli ;
2016-04-19 14:19:31 +00:00
2016-08-09 14:04:13 +00:00
my $ ext_ip = "" ;
2016-04-19 14:19:31 +00:00
if ( $ httpcli =~ /curl$/ ) {
2016-08-09 14:04:13 +00:00
$ ext_ip = infocmd_one "$httpcli ipecho.net/plain" ;
2016-04-18 14:45:34 +00:00
}
elsif ( $ httpcli =~ /wget$/ ) {
2016-08-09 14:04:13 +00:00
$ ext_ip = infocmd_one "$httpcli -q -O - ipecho.net/plain" ;
2016-04-18 14:45:34 +00:00
}
2016-08-09 14:04:13 +00:00
infoprint "External IP : " . $ ext_ip ;
$ result { 'Network' } { 'External Ip' } = $ ext_ip ;
2016-03-29 12:22:45 +00:00
badprint
2016-04-19 14:19:31 +00:00
"External IP : Can't check because of Internet connectivity"
unless defined ( $ httpcli ) ;
2016-03-29 12:22:45 +00:00
infoprint "Name Servers : "
. infocmd_one "grep 'nameserver' /etc/resolv.conf \| awk '{print \$2}'" ;
infoprint "Logged In users : " ;
infocmd_tab "who" ;
2016-08-09 14:04:13 +00:00
$ result { 'OS' } { 'Logged users' } = `who` ;
2016-04-04 11:58:52 +00:00
infoprint "Ram Usages in Mb : " ;
infocmd_tab "free -m | grep -v +" ;
2016-08-09 14:04:13 +00:00
$ result { 'OS' } { 'Free Memory RAM' } = `free -m | grep -v +` ;
2016-03-29 12:22:45 +00:00
infoprint "Load Average : " ;
infocmd_tab "top -n 1 -b | grep 'load average:'" ;
2016-08-09 14:04:13 +00:00
$ result { 'OS' } { 'Load Average' } = `top -n 1 -b | grep 'load average:'` ;
2016-03-25 15:22:07 +00:00
#infoprint "System Uptime Days/(HH:MM) : `uptime | awk '{print $3,$4}' | cut -f1 -d,`";
}
2016-03-21 16:11:20 +00:00
sub system_recommendations {
2016-04-19 14:19:31 +00:00
return if ( $ opt { sysstat } == 0 ) ;
subheaderprint "System Linux Recommendations" ;
2016-03-21 16:11:20 +00:00
my $ os = `uname` ;
2016-03-29 12:22:45 +00:00
unless ( $ os =~ /Linux/i ) {
2016-03-21 16:11:20 +00:00
infoprint "Skipped due to non Linux server" ;
return ;
2016-03-29 12:22:45 +00:00
}
2016-04-22 15:22:00 +00:00
prettyprint "Look for related Linux system recommendations" ;
2016-03-29 12:22:45 +00:00
2016-03-22 13:44:01 +00:00
#prettyprint '-'x78;
2016-03-25 15:22:07 +00:00
get_system_info ( ) ;
2016-03-29 12:22:45 +00:00
my $ omem = get_other_process_memory ;
infoprint "User process except mysqld used "
. hr_bytes_rnd ( $ omem ) . " RAM." ;
if ( ( 0.15 * $ physical_memory ) < $ omem ) {
badprint
"Other user process except mysqld used more than 15% of total physical memory "
. percentage ( $ omem , $ physical_memory ) . "% ("
. hr_bytes_rnd ( $ omem ) . " / "
. hr_bytes_rnd ( $ physical_memory ) . ")" ;
push ( @ generalrec ,
2016-04-22 15:22:00 +00:00
"Consider stopping or dedicate server for additional process other than mysqld."
2016-03-29 12:22:45 +00:00
) ;
push ( @ adjvars ,
"DON'T APPLY SETTINGS BECAUSE THERE ARE TOO MANY PROCESSES RUNNING ON THIS SERVER. OOM KILL CAN OCCUR!"
) ;
}
else {
infoprint
"Other user process except mysqld used less than 15% of total physical memory "
. percentage ( $ omem , $ physical_memory ) . "% ("
. hr_bytes_rnd ( $ omem ) . " / "
. hr_bytes_rnd ( $ physical_memory ) . ")" ;
}
if ( $ opt { 'maxportallowed' } > 0 ) {
my @ opened_ports = get_opened_ports ;
infoprint "There is "
. scalar @ opened_ports
. " listening port(s) on this server." ;
if ( scalar ( @ opened_ports ) > $ opt { 'maxportallowed' } ) {
badprint "There is too many listening ports: "
. scalar ( @ opened_ports )
. " opened > "
. $ opt { 'maxportallowed' }
. "allowed." ;
push ( @ generalrec ,
"Consider dedicating a server for your database installation with less services running on !"
) ;
}
else {
goodprint "There is less than "
. $ opt { 'maxportallowed' }
. " opened ports on this server." ;
}
2016-03-21 16:11:20 +00:00
}
2016-03-24 09:21:02 +00:00
2016-03-21 16:41:14 +00:00
foreach my $ banport ( @ banned_ports ) {
2016-03-29 12:22:45 +00:00
if ( is_open_port ( $ banport ) ) {
badprint "Banned port: $banport is opened.." ;
push ( @ generalrec ,
"Port $banport is opened. Consider stopping program handling this port."
) ;
}
else {
goodprint "$banport is not opened." ;
}
2016-03-21 16:41:14 +00:00
}
2016-03-25 13:32:15 +00:00
get_fs_info ;
2016-04-04 10:12:09 +00:00
get_kernel_info ;
2016-03-21 16:11:20 +00:00
}
2016-03-25 10:57:35 +00:00
2009-09-17 23:13:22 +00:00
sub security_recommendations {
2016-04-11 10:01:01 +00:00
subheaderprint "Security Recommendations" ;
2015-08-19 12:45:24 +00:00
if ( $ opt { skippassword } eq 1 ) {
infoprint "Skipped due to --skippassword option" ;
return ;
}
2016-03-29 12:22:45 +00:00
my $ PASS_COLUMN_NAME = 'password' ;
if ( $ myvar { 'version' } =~ /5.7/ ) {
$ PASS_COLUMN_NAME = 'authentication_string' ;
2015-12-08 15:58:16 +00:00
}
2015-12-10 10:52:39 +00:00
debugprint "Password column = $PASS_COLUMN_NAME" ;
2016-03-29 12:22:45 +00:00
2015-08-19 12:45:24 +00:00
# Looking for Anonymous users
my @ mysqlstatlist = select_array
"SELECT CONCAT(user, '\@', host) FROM mysql.user WHERE TRIM(USER) = '' OR USER IS NULL" ;
2016-03-21 14:51:16 +00:00
debugprint Dumper \ @ mysqlstatlist ;
2016-03-29 12:22:45 +00:00
2016-03-21 14:51:16 +00:00
#exit 0;
2015-08-19 12:45:24 +00:00
if ( @ mysqlstatlist ) {
foreach my $ line ( sort @ mysqlstatlist ) {
chomp ( $ line ) ;
badprint "User '" . $ line . "' is an anonymous account." ;
}
push ( @ generalrec ,
2015-09-16 16:11:42 +00:00
"Remove Anonymous User accounts - there are "
2015-08-19 12:45:24 +00:00
. scalar ( @ mysqlstatlist )
2015-12-10 10:52:39 +00:00
. " anonymous accounts." ) ;
2015-08-19 12:45:24 +00:00
}
else {
2015-11-13 14:54:24 +00:00
goodprint "There are no anonymous accounts for any database users" ;
2015-08-19 12:45:24 +00:00
}
2016-04-29 12:19:46 +00:00
if ( mysql_version_le ( 5 , 1 ) ) {
badprint "No more password checks for MySQL version <=5.1" ;
badprint "MySQL version <=5.1 are deprecated and end of support." ;
return ;
}
2015-08-19 12:45:24 +00:00
# Looking for Empty Password
@ mysqlstatlist = select_array
2016-03-25 10:57:35 +00:00
"SELECT CONCAT(user, '\@', host) FROM mysql.user WHERE ($PASS_COLUMN_NAME = '' OR $PASS_COLUMN_NAME IS NULL) AND plugin NOT IN ('unix_socket', 'win_socket')" ;
2015-08-19 12:45:24 +00:00
if ( @ mysqlstatlist ) {
foreach my $ line ( sort @ mysqlstatlist ) {
chomp ( $ line ) ;
badprint "User '" . $ line . "' has no password set." ;
}
push ( @ generalrec ,
"Set up a Password for user with the following SQL statement ( SET PASSWORD FOR 'user'\@'SpecificDNSorIp' = PASSWORD('secure_password'); )"
) ;
}
else {
goodprint "All database users have passwords assigned" ;
}
2016-03-29 12:22:45 +00:00
if ( mysql_version_ge ( 5 , 7 ) ) {
my $ valPlugin = select_one (
"select count(*) from information_schema.plugins where PLUGIN_NAME='validate_password' AND PLUGIN_STATUS='ACTIVE'"
) ;
if ( $ valPlugin >= 1 ) {
infoprint
"Bug #80860 MySQL 5.7: Avoid testing password when validate_password is activated" ;
return ;
}
2016-03-25 10:57:35 +00:00
}
2015-08-19 12:45:24 +00:00
# Looking for User with user/ uppercase /capitalise user as password
@ mysqlstatlist = select_array
2016-08-23 22:21:18 +00:00
"SELECT CONCAT(user, '\@', host) FROM mysql.user WHERE CAST($PASS_COLUMN_NAME as Binary) = PASSWORD(user) OR CAST($PASS_COLUMN_NAME as Binary) = PASSWORD(UPPER(user)) OR CAST($PASS_COLUMN_NAME as Binary) = PASSWORD(CONCAT(UPPER(LEFT(User, 1)), SUBSTRING(User, 2, LENGTH(User))))" ;
2015-08-19 12:45:24 +00:00
if ( @ mysqlstatlist ) {
foreach my $ line ( sort @ mysqlstatlist ) {
chomp ( $ line ) ;
badprint "User '" . $ line . "' has user name as password." ;
}
push ( @ generalrec ,
"Set up a Secure Password for user\@host ( SET PASSWORD FOR 'user'\@'SpecificDNSorIp' = PASSWORD('secure_password'); )"
) ;
}
@ mysqlstatlist = select_array
"SELECT CONCAT(user, '\@', host) FROM mysql.user WHERE HOST='%'" ;
if ( @ mysqlstatlist ) {
foreach my $ line ( sort @ mysqlstatlist ) {
chomp ( $ line ) ;
badprint "User '" . $ line . "' hasn't specific host restriction." ;
}
push ( @ generalrec ,
"Restrict Host for user\@% to user\@SpecificDNSorIp" ) ;
}
unless ( - f $ basic_password_files ) {
2015-12-10 10:52:39 +00:00
badprint "There is no basic password file list!" ;
2015-08-19 12:45:24 +00:00
return ;
}
my @ passwords = get_basic_passwords $ basic_password_files ;
2015-11-13 14:54:24 +00:00
infoprint "There are "
2015-08-19 12:45:24 +00:00
. scalar ( @ passwords )
. " basic passwords in the list." ;
my $ nbins = 0 ;
my $ passreq ;
if ( @ passwords ) {
foreach my $ pass ( @ passwords ) {
$ pass =~ s/\s//g ;
chomp ( $ pass ) ;
# Looking for User with user/ uppercase /capitalise weak password
@ mysqlstatlist =
select_array
2015-12-10 10:52:39 +00:00
"SELECT CONCAT(user, '\@', host) FROM mysql.user WHERE $PASS_COLUMN_NAME = PASSWORD('"
2015-08-19 12:45:24 +00:00
. $ pass
2015-12-10 10:52:39 +00:00
. "') OR $PASS_COLUMN_NAME = PASSWORD(UPPER('"
2015-08-19 12:45:24 +00:00
. $ pass
2016-08-23 22:21:18 +00:00
. "')) OR $PASS_COLUMN_NAME = PASSWORD(CONCAT(UPPER(LEFT('"
2015-08-19 12:45:24 +00:00
. $ pass
2016-08-23 22:21:18 +00:00
. "', 1)), SUBSTRING('"
2015-08-19 12:45:24 +00:00
. $ pass
. "', 2, LENGTH('"
2016-08-23 22:21:18 +00:00
. $ pass . "'))))" ;
2015-08-19 12:45:24 +00:00
debugprint "There is " . scalar ( @ mysqlstatlist ) . " items." ;
if ( @ mysqlstatlist ) {
foreach my $ line ( @ mysqlstatlist ) {
chomp ( $ line ) ;
badprint "User '" . $ line
2016-04-22 15:22:00 +00:00
. "' is using weak password: $pass in a lower, upper or capitalize derivative version." ;
2015-08-19 12:45:24 +00:00
$ nbins + + ;
}
}
}
}
if ( $ nbins > 0 ) {
2016-04-22 15:22:00 +00:00
push ( @ generalrec , $ nbins . " user(s) used basic or weak password." ) ;
2015-08-19 12:45:24 +00:00
}
2009-09-17 23:13:22 +00:00
}
2015-08-19 12:45:24 +00:00
sub get_replication_status {
2016-04-19 14:19:31 +00:00
subheaderprint "Replication Metrics" ;
infoprint "Galera Synchronous replication: " . $ myvar { 'have_galera' } ;
2015-08-19 12:45:24 +00:00
if ( scalar ( keys % myslaves ) == 0 ) {
infoprint "No replication slave(s) for this server." ;
}
else {
infoprint "This server is acting as master for "
. scalar ( keys % myslaves )
. " server(s)." ;
}
if ( scalar ( keys % myrepl ) == 0 and scalar ( keys % myslaves ) == 0 ) {
2016-04-06 08:33:56 +00:00
infoprint "This is a standalone server." ;
2015-08-19 12:45:24 +00:00
return ;
}
if ( scalar ( keys % myrepl ) == 0 ) {
infoprint "No replication setup for this server." ;
return ;
}
2016-08-09 14:04:13 +00:00
$ result { 'Replication' } { 'status' } = \ % myrepl ;
2015-08-19 12:45:24 +00:00
my ( $ io_running ) = $ myrepl { 'Slave_IO_Running' } ;
debugprint "IO RUNNING: $io_running " ;
my ( $ sql_running ) = $ myrepl { 'Slave_SQL_Running' } ;
debugprint "SQL RUNNING: $sql_running " ;
my ( $ seconds_behind_master ) = $ myrepl { 'Seconds_Behind_Master' } ;
debugprint "SECONDS : $seconds_behind_master " ;
if ( defined ( $ io_running )
and ( $ io_running !~ /yes/i or $ sql_running !~ /yes/i ) )
{
badprint
2016-04-22 15:22:00 +00:00
"This replication slave is not running but seems to be configured." ;
2015-08-19 12:45:24 +00:00
}
if ( defined ( $ io_running )
2016-03-29 12:22:45 +00:00
&& $ io_running =~ /yes/i
2015-08-19 12:45:24 +00:00
&& $ sql_running =~ /yes/i )
{
if ( $ myvar { 'read_only' } eq 'OFF' ) {
badprint
"This replication slave is running with the read_only option disabled." ;
}
else {
goodprint
"This replication slave is running with the read_only option enabled." ;
}
if ( $ seconds_behind_master > 0 ) {
badprint
"This replication slave is lagging and slave has $seconds_behind_master second(s) behind master host." ;
}
else {
2015-12-10 10:52:39 +00:00
goodprint "This replication slave is up to date with master." ;
2015-08-19 12:45:24 +00:00
}
}
2009-09-17 23:13:22 +00:00
}
2008-09-08 01:16:39 +00:00
sub validate_mysql_version {
2015-08-19 12:45:24 +00:00
( $ mysqlvermajor , $ mysqlverminor , $ mysqlvermicro ) =
$ myvar { 'version' } =~ /^(\d+)(?:\.(\d+)|)(?:\.(\d+)|)/ ;
$ mysqlverminor || = 0 ;
$ mysqlvermicro || = 0 ;
if ( ! mysql_version_ge ( 5 , 1 ) ) {
badprint "Your MySQL version "
. $ myvar { 'version' }
. " is EOL software! Upgrade soon!" ;
}
2016-03-29 12:22:45 +00:00
elsif ( ( mysql_version_ge ( 6 ) and mysql_version_le ( 9 ) )
or mysql_version_ge ( 12 ) )
{
2015-08-19 12:45:24 +00:00
badprint "Currently running unsupported MySQL version "
. $ myvar { 'version' } . "" ;
2016-03-29 12:22:45 +00:00
}
else {
2015-08-19 12:45:24 +00:00
goodprint "Currently running supported MySQL version "
. $ myvar { 'version' } . "" ;
}
2008-09-08 01:16:39 +00:00
}
2015-07-15 14:58:18 +00:00
# Checks if MySQL version is greater than equal to (major, minor, micro)
2011-04-02 11:54:00 +00:00
sub mysql_version_ge {
2015-08-19 12:45:24 +00:00
my ( $ maj , $ min , $ mic ) = @ _ ;
$ min || = 0 ;
$ mic || = 0 ;
2016-08-26 08:40:58 +00:00
return int ( $ mysqlvermajor ) > int ( $ maj )
|| ( int ( $ mysqlvermajor ) == int ( $ maj ) && int ( $ mysqlverminor ) > int ( $ min ) )
|| ( int ( $ mysqlverminor ) == int ( $ min ) && int ( $ mysqlvermicro ) >= int ( $ mic ) ) ;
2011-04-02 11:54:00 +00:00
}
2015-08-24 07:51:03 +00:00
# Checks if MySQL version is lower than equal to (major, minor, micro)
sub mysql_version_le {
my ( $ maj , $ min , $ mic ) = @ _ ;
$ min || = 0 ;
$ mic || = 0 ;
2016-08-26 08:40:58 +00:00
return int ( $ mysqlvermajor ) < int ( $ maj )
|| ( int ( $ mysqlvermajor ) == int ( $ maj ) && int ( $ mysqlverminor ) < int ( $ min ) )
|| ( int ( $ mysqlverminor ) == int ( $ min ) && int ( $ mysqlvermicro ) <= int ( $ mic ) ) ;
2015-08-24 07:51:03 +00:00
}
2016-01-05 23:57:34 +00:00
# Checks if MySQL micro version is lower than equal to (major, minor, micro)
sub mysql_micro_version_le {
my ( $ maj , $ min , $ mic ) = @ _ ;
return $ mysqlvermajor == $ maj
&& ( $ mysqlverminor == $ min
2016-03-29 12:22:45 +00:00
&& $ mysqlvermicro <= $ mic ) ;
2016-01-05 23:57:34 +00:00
}
2008-09-08 01:16:39 +00:00
# Checks for 32-bit boxes with more than 2GB of RAM
my ( $ arch ) ;
2015-08-19 12:45:24 +00:00
2008-09-08 01:16:39 +00:00
sub check_architecture {
2015-08-19 12:45:24 +00:00
if ( $ doremote eq 1 ) { return ; }
if ( `uname` =~ /SunOS/ && `isainfo -b` =~ /64/ ) {
$ arch = 64 ;
goodprint "Operating on 64-bit architecture" ;
}
elsif ( `uname` !~ /SunOS/ && `uname -m` =~ /64/ ) {
$ arch = 64 ;
goodprint "Operating on 64-bit architecture" ;
}
elsif ( `uname` =~ /AIX/ && `bootinfo -K` =~ /64/ ) {
$ arch = 64 ;
goodprint "Operating on 64-bit architecture" ;
}
elsif ( `uname` =~ /NetBSD|OpenBSD/ && `sysctl -b hw.machine` =~ /64/ ) {
$ arch = 64 ;
goodprint "Operating on 64-bit architecture" ;
}
elsif ( `uname` =~ /FreeBSD/ && `sysctl -b hw.machine_arch` =~ /64/ ) {
$ arch = 64 ;
goodprint "Operating on 64-bit architecture" ;
}
elsif ( `uname` =~ /Darwin/ && `uname -m` =~ /Power Macintosh/ ) {
# Darwin box.local 9.8.0 Darwin Kernel Version 9.8.0: Wed Jul 15 16:57:01 PDT 2009; root:xnu1228.15.4~1/RELEASE_PPC Power Macintosh
$ arch = 64 ;
goodprint "Operating on 64-bit architecture" ;
}
elsif ( `uname` =~ /Darwin/ && `uname -m` =~ /x86_64/ ) {
# Darwin gibas.local 12.3.0 Darwin Kernel Version 12.3.0: Sun Jan 6 22:37:10 PST 2013; root:xnu-2050.22.13~1/RELEASE_X86_64 x86_64
$ arch = 64 ;
goodprint "Operating on 64-bit architecture" ;
}
else {
$ arch = 32 ;
if ( $ physical_memory > 2147483648 ) {
badprint
"Switch to 64-bit OS - MySQL cannot currently use all of your RAM" ;
}
else {
2016-03-29 12:22:45 +00:00
goodprint "Operating on 32-bit architecture with less than 2GB RAM" ;
2015-08-19 12:45:24 +00:00
}
}
$ result { 'OS' } { 'Architecture' } = "$arch bits" ;
2016-03-22 13:44:01 +00:00
2008-09-08 01:16:39 +00:00
}
# Start up a ton of storage engine counts/statistics
2015-08-19 12:45:24 +00:00
my ( % enginestats , % enginecount , $ fragtables ) ;
2008-09-08 01:16:39 +00:00
sub check_storage_engines {
2015-08-19 12:45:24 +00:00
if ( $ opt { skipsize } eq 1 ) {
2016-04-11 10:01:01 +00:00
subheaderprint "Storage Engine Statistics" ;
2015-08-19 12:45:24 +00:00
infoprint "Skipped due to --skipsize option" ;
return ;
}
2016-04-11 10:01:01 +00:00
subheaderprint "Storage Engine Statistics" ;
2015-08-19 12:45:24 +00:00
my $ engines ;
2016-03-16 17:40:44 +00:00
if ( mysql_version_ge ( 5 , 5 ) ) {
my @ engineresults = select_array
"SELECT ENGINE,SUPPORT FROM information_schema.ENGINES ORDER BY ENGINE ASC" ;
foreach my $ line ( @ engineresults ) {
my ( $ engine , $ engineenabled ) ;
( $ engine , $ engineenabled ) = $ line =~ /([a-zA-Z_]*)\s+([a-zA-Z]+)/ ;
$ result { 'Engine' } { $ engine } { 'Enabled' } = $ engineenabled ;
$ engines . =
( $ engineenabled eq "YES" || $ engineenabled eq "DEFAULT" )
? greenwrap "+" . $ engine . " "
: redwrap "-" . $ engine . " " ;
}
}
elsif ( mysql_version_ge ( 5 , 1 , 5 ) ) {
2015-08-19 12:45:24 +00:00
my @ engineresults = select_array
"SELECT ENGINE,SUPPORT FROM information_schema.ENGINES WHERE ENGINE NOT IN ('performance_schema','MyISAM','MERGE','MEMORY') ORDER BY ENGINE ASC" ;
foreach my $ line ( @ engineresults ) {
my ( $ engine , $ engineenabled ) ;
( $ engine , $ engineenabled ) = $ line =~ /([a-zA-Z_]*)\s+([a-zA-Z]+)/ ;
$ result { 'Engine' } { $ engine } { 'Enabled' } = $ engineenabled ;
$ engines . =
( $ engineenabled eq "YES" || $ engineenabled eq "DEFAULT" )
? greenwrap "+" . $ engine . " "
: redwrap "-" . $ engine . " " ;
}
}
else {
$ engines . =
( defined $ myvar { 'have_archive' } && $ myvar { 'have_archive' } eq "YES" )
? greenwrap "+Archive "
: redwrap "-Archive " ;
$ engines . =
( defined $ myvar { 'have_bdb' } && $ myvar { 'have_bdb' } eq "YES" )
? greenwrap "+BDB "
: redwrap "-BDB " ;
$ engines . =
( defined $ myvar { 'have_federated_engine' }
&& $ myvar { 'have_federated_engine' } eq "YES" )
? greenwrap "+Federated "
: redwrap "-Federated " ;
$ engines . =
( defined $ myvar { 'have_innodb' } && $ myvar { 'have_innodb' } eq "YES" )
? greenwrap "+InnoDB "
: redwrap "-InnoDB " ;
$ engines . =
( defined $ myvar { 'have_isam' } && $ myvar { 'have_isam' } eq "YES" )
? greenwrap "+ISAM "
: redwrap "-ISAM " ;
$ engines . =
( defined $ myvar { 'have_ndbcluster' }
&& $ myvar { 'have_ndbcluster' } eq "YES" )
? greenwrap "+NDBCluster "
: redwrap "-NDBCluster " ;
}
2016-03-29 12:22:45 +00:00
my @ dblist = grep { $ _ ne 'lost+found' } select_array "SHOW DATABASES" ;
2015-09-02 13:40:57 +00:00
2015-08-19 12:45:24 +00:00
$ result { 'Databases' } { 'List' } = [ @ dblist ] ;
infoprint "Status: $engines" ;
if ( mysql_version_ge ( 5 , 1 , 5 ) ) {
2016-03-29 12:22:45 +00:00
# MySQL 5 servers can have table sizes calculated quickly from information schema
2015-08-19 12:45:24 +00:00
my @ templist = select_array
"SELECT ENGINE,SUM(DATA_LENGTH+INDEX_LENGTH),COUNT(ENGINE),SUM(DATA_LENGTH),SUM(INDEX_LENGTH) FROM information_schema.TABLES WHERE TABLE_SCHEMA NOT IN ('information_schema', 'performance_schema', 'mysql') AND ENGINE IS NOT NULL GROUP BY ENGINE ORDER BY ENGINE ASC;" ;
my ( $ engine , $ size , $ count , $ dsize , $ isize ) ;
foreach my $ line ( @ templist ) {
( $ engine , $ size , $ count , $ dsize , $ isize ) =
2016-08-26 08:40:58 +00:00
$ line =~ /([a-zA-Z_]+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/ ;
debugprint "Engine Found: $engine" ;
next unless ( defined ( $ engine ) ) ;
2016-06-10 08:24:40 +00:00
$ size = 0 unless defined ( $ size ) ;
$ isize = 0 unless defined ( $ isize ) ;
$ dsize = 0 unless defined ( $ dsize ) ;
$ count = 0 unless defined ( $ count ) ;
2015-08-19 12:45:24 +00:00
$ enginestats { $ engine } = $ size ;
$ enginecount { $ engine } = $ count ;
$ result { 'Engine' } { $ engine } { 'Table Number' } = $ count ;
$ result { 'Engine' } { $ engine } { 'Total Size' } = $ size ;
$ result { 'Engine' } { $ engine } { 'Data Size' } = $ dsize ;
$ result { 'Engine' } { $ engine } { 'Index Size' } = $ isize ;
}
2016-06-02 07:23:46 +00:00
my $ not_innodb = '' ;
if ( $ result { 'Variables' } { 'innodb_file_per_table' } eq 'OFF' ) {
$ not_innodb = "AND NOT ENGINE='InnoDB'" ;
}
2015-08-19 12:45:24 +00:00
$ result { 'Tables' } { 'Fragmented tables' } =
[ select_array
2016-06-02 07:23:46 +00:00
"SELECT CONCAT(CONCAT(TABLE_SCHEMA, '.'), TABLE_NAME),DATA_FREE FROM information_schema.TABLES WHERE TABLE_SCHEMA NOT IN ('information_schema','performance_schema', 'mysql') AND DATA_LENGTH/1024/1024>100 AND DATA_FREE*100/(DATA_LENGTH+INDEX_LENGTH+DATA_FREE) > 10 AND NOT ENGINE='MEMORY' $not_innodb"
2015-08-19 12:45:24 +00:00
] ;
2016-06-02 07:23:46 +00:00
$ fragtables = scalar @ { $ result { 'Tables' } { 'Fragmented tables' } } ;
2015-08-19 12:45:24 +00:00
}
else {
# MySQL < 5 servers take a lot of work to get table sizes
my @ tblist ;
2016-03-29 12:22:45 +00:00
# Now we build a database list, and loop through it to get storage engine stats for tables
2015-08-19 12:45:24 +00:00
foreach my $ db ( @ dblist ) {
chomp ( $ db ) ;
if ( $ db eq "information_schema"
or $ db eq "performance_schema"
2015-11-23 07:08:25 +00:00
or $ db eq "mysql"
2015-09-02 12:13:49 +00:00
or $ db eq "lost+found" )
2015-08-19 12:45:24 +00:00
{
next ;
}
my @ ixs = ( 1 , 6 , 9 ) ;
if ( ! mysql_version_ge ( 4 , 1 ) ) {
# MySQL 3.23/4.0 keeps Data_Length in the 5th (0-based) column
@ ixs = ( 1 , 5 , 8 ) ;
}
push ( @ tblist ,
map { [ ( split ) [ @ ixs ] ] }
select_array "SHOW TABLE STATUS FROM \\\`$db\\\`" ) ;
}
# Parse through the table list to generate storage engine counts/statistics
$ fragtables = 0 ;
foreach my $ tbl ( @ tblist ) {
2016-03-29 12:22:45 +00:00
debugprint "Data dump " . Dumper ( @$ tbl ) ;
2015-08-19 12:45:24 +00:00
my ( $ engine , $ size , $ datafree ) = @$ tbl ;
2015-09-02 13:40:57 +00:00
next if $ engine eq 'NULL' ;
2016-03-29 12:22:45 +00:00
$ size = 0 if $ size eq 'NULL' ;
$ datafree = 0 if $ datafree eq 'NULL' ;
2015-08-19 12:45:24 +00:00
if ( defined $ enginestats { $ engine } ) {
$ enginestats { $ engine } += $ size ;
$ enginecount { $ engine } += 1 ;
}
else {
$ enginestats { $ engine } = $ size ;
$ enginecount { $ engine } = 1 ;
}
if ( $ datafree > 0 ) {
$ fragtables + + ;
}
}
}
while ( my ( $ engine , $ size ) = each ( % enginestats ) ) {
infoprint "Data in $engine tables: "
. hr_bytes_rnd ( $ size )
. " (Tables: "
. $ enginecount { $ engine } . ")" . "" ;
}
# If the storage engine isn't being used, recommend it to be disabled
if ( ! defined $ enginestats { 'InnoDB' }
&& defined $ myvar { 'have_innodb' }
&& $ myvar { 'have_innodb' } eq "YES" )
{
badprint "InnoDB is enabled but isn't being used" ;
push ( @ generalrec ,
"Add skip-innodb to MySQL configuration to disable InnoDB" ) ;
}
if ( ! defined $ enginestats { 'BerkeleyDB' }
&& defined $ myvar { 'have_bdb' }
&& $ myvar { 'have_bdb' } eq "YES" )
{
badprint "BDB is enabled but isn't being used" ;
push ( @ generalrec ,
"Add skip-bdb to MySQL configuration to disable BDB" ) ;
}
if ( ! defined $ enginestats { 'ISAM' }
&& defined $ myvar { 'have_isam' }
&& $ myvar { 'have_isam' } eq "YES" )
{
badprint "MYISAM is enabled but isn't being used" ;
push ( @ generalrec ,
"Add skip-isam to MySQL configuration to disable ISAM (MySQL > 4.1.0)"
) ;
}
# Fragmented tables
if ( $ fragtables > 0 ) {
badprint "Total fragmented tables: $fragtables" ;
push ( @ generalrec ,
"Run OPTIMIZE TABLE to defragment tables for better performance" ) ;
2016-06-02 07:23:46 +00:00
my $ total_free = 0 ;
foreach my $ table_line ( @ { $ result { 'Tables' } { 'Fragmented tables' } } ) {
my ( $ table_name , $ data_free ) = split ( /\s+/ , $ table_line ) ;
2016-08-30 12:57:09 +00:00
$ data_free = 0 if ( ! defined ( $ data_free ) or $ data_free eq '' ) ;
2016-06-02 07:23:46 +00:00
$ data_free = $ data_free /1024/ 1024 ;
$ total_free += $ data_free ;
push ( @ generalrec ,
2016-06-03 13:50:19 +00:00
" OPTIMIZE TABLE $table_name; -- can free $data_free MB" ) ;
2016-06-02 07:23:46 +00:00
}
push ( @ generalrec ,
"Total freed space after theses OPTIMIZE TABLE : $total_free Mb" ) ;
2015-08-19 12:45:24 +00:00
}
else {
goodprint "Total fragmented tables: $fragtables" ;
}
# Auto increments
my % tblist ;
# Find the maximum integer
my $ maxint = select_one "SELECT ~0" ;
$ result { 'MaxInt' } = $ maxint ;
# Now we use a database list, and loop through it to get storage engine stats for tables
foreach my $ db ( @ dblist ) {
chomp ( $ db ) ;
if ( ! $ tblist { $ db } ) {
$ tblist { $ db } = ( ) ;
}
if ( $ db eq "information_schema" ) { next ; }
my @ ia = ( 0 , 10 ) ;
if ( ! mysql_version_ge ( 4 , 1 ) ) {
# MySQL 3.23/4.0 keeps Data_Length in the 5th (0-based) column
@ ia = ( 0 , 9 ) ;
}
push (
@ { $ tblist { $ db } } ,
map { [ ( split ) [ @ ia ] ] }
select_array "SHOW TABLE STATUS FROM \\\`$db\\\`"
) ;
}
my @ dbnames = keys % tblist ;
foreach my $ db ( @ dbnames ) {
foreach my $ tbl ( @ { $ tblist { $ db } } ) {
my ( $ name , $ autoincrement ) = @$ tbl ;
if ( $ autoincrement =~ /^\d+?$/ ) {
my $ percent = percentage ( $ autoincrement , $ maxint ) ;
$ result { 'PctAutoIncrement' } { "$db.$name" } = $ percent ;
if ( $ percent >= 75 ) {
badprint
"Table '$db.$name' has an autoincrement value near max capacity ($percent%)" ;
}
}
}
}
2014-12-04 07:14:02 +00:00
2008-09-08 01:16:39 +00:00
}
my % mycalc ;
2015-08-19 12:45:24 +00:00
2008-09-08 01:16:39 +00:00
sub calculations {
2015-08-19 12:45:24 +00:00
if ( $ mystat { 'Questions' } < 1 ) {
badprint
"Your server has not answered any queries - cannot continue..." ;
2015-08-24 08:00:10 +00:00
exit 2 ;
2015-08-19 12:45:24 +00:00
}
# Per-thread memory
if ( mysql_version_ge ( 4 ) ) {
$ mycalc { 'per_thread_buffers' } =
$ myvar { 'read_buffer_size' } +
$ myvar { 'read_rnd_buffer_size' } +
$ myvar { 'sort_buffer_size' } +
$ myvar { 'thread_stack' } +
$ myvar { 'join_buffer_size' } ;
}
else {
$ mycalc { 'per_thread_buffers' } =
$ myvar { 'record_buffer' } +
$ myvar { 'record_rnd_buffer' } +
$ myvar { 'sort_buffer' } +
$ myvar { 'thread_stack' } +
$ myvar { 'join_buffer_size' } ;
}
$ mycalc { 'total_per_thread_buffers' } =
$ mycalc { 'per_thread_buffers' } * $ myvar { 'max_connections' } ;
$ mycalc { 'max_total_per_thread_buffers' } =
$ mycalc { 'per_thread_buffers' } * $ mystat { 'Max_used_connections' } ;
# Server-wide memory
$ mycalc { 'max_tmp_table_size' } =
( $ myvar { 'tmp_table_size' } > $ myvar { 'max_heap_table_size' } )
? $ myvar { 'max_heap_table_size' }
: $ myvar { 'tmp_table_size' } ;
$ mycalc { 'server_buffers' } =
$ myvar { 'key_buffer_size' } + $ mycalc { 'max_tmp_table_size' } ;
$ mycalc { 'server_buffers' } +=
( defined $ myvar { 'innodb_buffer_pool_size' } )
? $ myvar { 'innodb_buffer_pool_size' }
: 0 ;
$ mycalc { 'server_buffers' } +=
( defined $ myvar { 'innodb_additional_mem_pool_size' } )
? $ myvar { 'innodb_additional_mem_pool_size' }
: 0 ;
$ mycalc { 'server_buffers' } +=
( defined $ myvar { 'innodb_log_buffer_size' } )
? $ myvar { 'innodb_log_buffer_size' }
: 0 ;
$ mycalc { 'server_buffers' } +=
( defined $ myvar { 'query_cache_size' } ) ? $ myvar { 'query_cache_size' } : 0 ;
$ mycalc { 'server_buffers' } +=
( defined $ myvar { 'aria_pagecache_buffer_size' } )
? $ myvar { 'aria_pagecache_buffer_size' }
: 0 ;
# Global memory
# Max used memory is memory used by MySQL based on Max_used_connections
# This is the max memory used theorically calculated with the max concurrent connection number reached by mysql
$ mycalc { 'max_used_memory' } =
2016-04-19 14:19:31 +00:00
$ mycalc { 'server_buffers' } +
$ mycalc { "max_total_per_thread_buffers" } +
get_pf_memory ( ) +
get_gcache_memory ( ) ;
2015-08-19 12:45:24 +00:00
$ mycalc { 'pct_max_used_memory' } =
percentage ( $ mycalc { 'max_used_memory' } , $ physical_memory ) ;
# Total possible memory is memory needed by MySQL based on max_connections
# This is the max memory MySQL can theorically used if all connections allowed has opened by mysql
$ mycalc { 'max_peak_memory' } =
2016-04-19 14:19:31 +00:00
$ mycalc { 'server_buffers' } +
$ mycalc { 'total_per_thread_buffers' } +
get_pf_memory ( ) +
get_gcache_memory ( ) ;
2015-08-19 12:45:24 +00:00
$ mycalc { 'pct_max_physical_memory' } =
percentage ( $ mycalc { 'max_peak_memory' } , $ physical_memory ) ;
debugprint "Max Used Memory: "
. hr_bytes ( $ mycalc { 'max_used_memory' } ) . "" ;
debugprint "Max Used Percentage RAM: "
. $ mycalc { 'pct_max_used_memory' } . "%" ;
debugprint "Max Peak Memory: "
. hr_bytes ( $ mycalc { 'max_peak_memory' } ) . "" ;
debugprint "Max Peak Percentage RAM: "
. $ mycalc { 'pct_max_physical_memory' } . "%" ;
2016-04-19 14:19:31 +00:00
2015-08-19 12:45:24 +00:00
# Slow queries
$ mycalc { 'pct_slow_queries' } =
int ( ( $ mystat { 'Slow_queries' } / $ mystat { 'Questions' } ) * 100 ) ;
# Connections
$ mycalc { 'pct_connections_used' } = int (
( $ mystat { 'Max_used_connections' } / $ myvar { 'max_connections' } ) * 100 ) ;
$ mycalc { 'pct_connections_used' } =
( $ mycalc { 'pct_connections_used' } > 100 )
? 100
: $ mycalc { 'pct_connections_used' } ;
# Aborted Connections
$ mycalc { 'pct_connections_aborted' } =
percentage ( $ mystat { 'Aborted_connects' } , $ mystat { 'Connections' } ) ;
debugprint "Aborted_connects: " . $ mystat { 'Aborted_connects' } . "" ;
debugprint "Connections: " . $ mystat { 'Connections' } . "" ;
debugprint "pct_connections_aborted: "
. $ mycalc { 'pct_connections_aborted' } . "" ;
# Key buffers
if ( mysql_version_ge ( 4 , 1 ) && $ myvar { 'key_buffer_size' } > 0 ) {
$ mycalc { 'pct_key_buffer_used' } = sprintf (
"%.1f" ,
(
1 - (
(
$ mystat { 'Key_blocks_unused' } *
$ myvar { 'key_cache_block_size' }
) / $ myvar { 'key_buffer_size' }
)
2016-03-29 12:22:45 +00:00
) * 100
2015-08-19 12:45:24 +00:00
) ;
}
else {
$ mycalc { 'pct_key_buffer_used' } = 0 ;
}
if ( $ mystat { 'Key_read_requests' } > 0 ) {
$ mycalc { 'pct_keys_from_mem' } = sprintf (
"%.1f" ,
(
100 - (
( $ mystat { 'Key_reads' } / $ mystat { 'Key_read_requests' } ) *
100
)
)
) ;
}
else {
$ mycalc { 'pct_keys_from_mem' } = 0 ;
}
if ( defined $ mystat { 'Aria_pagecache_read_requests' }
&& $ mystat { 'Aria_pagecache_read_requests' } > 0 )
{
$ mycalc { 'pct_aria_keys_from_mem' } = sprintf (
"%.1f" ,
(
100 - (
(
$ mystat { 'Aria_pagecache_reads' } /
$ mystat { 'Aria_pagecache_read_requests' }
) * 100
)
)
) ;
}
else {
$ mycalc { 'pct_aria_keys_from_mem' } = 0 ;
}
if ( $ mystat { 'Key_write_requests' } > 0 ) {
$ mycalc { 'pct_wkeys_from_mem' } = sprintf (
"%.1f" ,
(
100 - (
( $ mystat { 'Key_writes' } / $ mystat { 'Key_write_requests' } ) *
100
)
)
) ;
}
else {
$ mycalc { 'pct_wkeys_from_mem' } = 0 ;
}
if ( $ doremote eq 0 and ! mysql_version_ge ( 5 ) ) {
my $ size = 0 ;
$ size += ( split ) [ 0 ]
for
`find $myvar{'datadir'} -name "*.MYI" 2>&1 | xargs du -L $duflags 2>&1` ;
$ mycalc { 'total_myisam_indexes' } = $ size ;
$ mycalc { 'total_aria_indexes' } = 0 ;
}
elsif ( mysql_version_ge ( 5 ) ) {
$ mycalc { 'total_myisam_indexes' } = select_one
"SELECT IFNULL(SUM(INDEX_LENGTH),0) FROM information_schema.TABLES WHERE TABLE_SCHEMA NOT IN ('information_schema') AND ENGINE = 'MyISAM';" ;
2015-10-09 09:14:39 +00:00
$ mycalc { 'total_aria_indexes' } = select_one
2015-08-19 12:45:24 +00:00
"SELECT IFNULL(SUM(INDEX_LENGTH),0) FROM information_schema.TABLES WHERE TABLE_SCHEMA NOT IN ('information_schema') AND ENGINE = 'Aria';" ;
}
if ( defined $ mycalc { 'total_myisam_indexes' }
and $ mycalc { 'total_myisam_indexes' } == 0 )
{
$ mycalc { 'total_myisam_indexes' } = "fail" ;
}
elsif ( defined $ mycalc { 'total_myisam_indexes' } ) {
chomp ( $ mycalc { 'total_myisam_indexes' } ) ;
}
if ( defined $ mycalc { 'total_aria_indexes' }
and $ mycalc { 'total_aria_indexes' } == 0 )
{
2016-04-05 16:25:20 +00:00
$ mycalc { 'total_aria_indexes' } = 1 ;
2015-08-19 12:45:24 +00:00
}
elsif ( defined $ mycalc { 'total_aria_indexes' } ) {
chomp ( $ mycalc { 'total_aria_indexes' } ) ;
}
# Query cache
if ( mysql_version_ge ( 4 ) ) {
$ mycalc { 'query_cache_efficiency' } = sprintf (
"%.1f" ,
(
$ mystat { 'Qcache_hits' } /
( $ mystat { 'Com_select' } + $ mystat { 'Qcache_hits' } )
2016-03-29 12:22:45 +00:00
) * 100
2015-08-19 12:45:24 +00:00
) ;
if ( $ myvar { 'query_cache_size' } ) {
$ mycalc { 'pct_query_cache_used' } = sprintf (
"%.1f" ,
100 - (
$ mystat { 'Qcache_free_memory' } / $ myvar { 'query_cache_size' }
2016-03-29 12:22:45 +00:00
) * 100
2015-08-19 12:45:24 +00:00
) ;
}
if ( $ mystat { 'Qcache_lowmem_prunes' } == 0 ) {
$ mycalc { 'query_cache_prunes_per_day' } = 0 ;
}
else {
$ mycalc { 'query_cache_prunes_per_day' } = int (
$ mystat { 'Qcache_lowmem_prunes' } / ( $mystat{'Uptime'} / 86400 )
) ;
}
}
# Sorting
$ mycalc { 'total_sorts' } = $ mystat { 'Sort_scan' } + $ mystat { 'Sort_range' } ;
if ( $ mycalc { 'total_sorts' } > 0 ) {
$ mycalc { 'pct_temp_sort_table' } = int (
( $ mystat { 'Sort_merge_passes' } / $ mycalc { 'total_sorts' } ) * 100 ) ;
}
# Joins
$ mycalc { 'joins_without_indexes' } =
$ mystat { 'Select_range_check' } + $ mystat { 'Select_full_join' } ;
$ mycalc { 'joins_without_indexes_per_day' } =
int ( $ mycalc { 'joins_without_indexes' } / ( $mystat{'Uptime'} / 86400 ) ) ;
# Temporary tables
if ( $ mystat { 'Created_tmp_tables' } > 0 ) {
if ( $ mystat { 'Created_tmp_disk_tables' } > 0 ) {
$ mycalc { 'pct_temp_disk' } = int (
(
$ mystat { 'Created_tmp_disk_tables' } /
$ mystat { 'Created_tmp_tables' }
) * 100
) ;
}
else {
$ mycalc { 'pct_temp_disk' } = 0 ;
}
}
# Table cache
if ( $ mystat { 'Opened_tables' } > 0 ) {
$ mycalc { 'table_cache_hit_rate' } =
int ( $ mystat { 'Open_tables' } * 100 / $ mystat { 'Opened_tables' } ) ;
}
else {
$ mycalc { 'table_cache_hit_rate' } = 100 ;
}
# Open files
if ( $ myvar { 'open_files_limit' } > 0 ) {
$ mycalc { 'pct_files_open' } =
int ( $ mystat { 'Open_files' } * 100 / $ myvar { 'open_files_limit' } ) ;
}
# Table locks
if ( $ mystat { 'Table_locks_immediate' } > 0 ) {
if ( $ mystat { 'Table_locks_waited' } == 0 ) {
$ mycalc { 'pct_table_locks_immediate' } = 100 ;
}
else {
$ mycalc { 'pct_table_locks_immediate' } = int (
$ mystat { 'Table_locks_immediate' } * 100 / (
$ mystat { 'Table_locks_waited' } +
$ mystat { 'Table_locks_immediate' }
)
) ;
}
}
# Thread cache
$ mycalc { 'thread_cache_hit_rate' } =
int ( 100 -
( ( $ mystat { 'Threads_created' } / $ mystat { 'Connections' } ) * 100 ) ) ;
# Other
if ( $ mystat { 'Connections' } > 0 ) {
$ mycalc { 'pct_aborted_connections' } =
int ( ( $ mystat { 'Aborted_connects' } / $ mystat { 'Connections' } ) * 100 ) ;
}
if ( $ mystat { 'Questions' } > 0 ) {
$ mycalc { 'total_reads' } = $ mystat { 'Com_select' } ;
$ mycalc { 'total_writes' } =
$ mystat { 'Com_delete' } +
$ mystat { 'Com_insert' } +
$ mystat { 'Com_update' } +
$ mystat { 'Com_replace' } ;
if ( $ mycalc { 'total_reads' } == 0 ) {
$ mycalc { 'pct_reads' } = 0 ;
$ mycalc { 'pct_writes' } = 100 ;
}
else {
$ mycalc { 'pct_reads' } = int (
(
$ mycalc { 'total_reads' } /
( $ mycalc { 'total_reads' } + $ mycalc { 'total_writes' } )
) * 100
) ;
$ mycalc { 'pct_writes' } = 100 - $ mycalc { 'pct_reads' } ;
}
}
# InnoDB
if ( $ myvar { 'have_innodb' } eq "YES" ) {
$ mycalc { 'innodb_log_size_pct' } =
( $ myvar { 'innodb_log_file_size' } * 100 /
$ myvar { 'innodb_buffer_pool_size' } ) ;
}
2016-02-24 19:20:48 +00:00
# InnoDB Buffer pool read cache effiency
2015-08-19 12:45:24 +00:00
(
$ mystat { 'Innodb_buffer_pool_read_requests' } ,
$ mystat { 'Innodb_buffer_pool_reads' }
)
= ( 1 , 1 )
unless defined $ mystat { 'Innodb_buffer_pool_reads' } ;
$ mycalc { 'pct_read_efficiency' } = percentage (
(
$ mystat { 'Innodb_buffer_pool_read_requests' } -
$ mystat { 'Innodb_buffer_pool_reads' }
) ,
$ mystat { 'Innodb_buffer_pool_read_requests' }
) if defined $ mystat { 'Innodb_buffer_pool_read_requests' } ;
debugprint "pct_read_efficiency: " . $ mycalc { 'pct_read_efficiency' } . "" ;
debugprint "Innodb_buffer_pool_reads: "
. $ mystat { 'Innodb_buffer_pool_reads' } . "" ;
debugprint "Innodb_buffer_pool_read_requests: "
. $ mystat { 'Innodb_buffer_pool_read_requests' } . "" ;
2016-02-24 19:20:48 +00:00
# InnoDB log write cache effiency
2016-03-29 12:22:45 +00:00
( $ mystat { 'Innodb_log_write_requests' } , $ mystat { 'Innodb_log_writes' } ) =
( 1 , 1 )
2016-02-24 19:20:48 +00:00
unless defined $ mystat { 'Innodb_log_writes' } ;
2015-08-19 12:45:24 +00:00
$ mycalc { 'pct_write_efficiency' } = percentage (
2016-03-29 12:22:45 +00:00
( $ mystat { 'Innodb_log_write_requests' } - $ mystat { 'Innodb_log_writes' } ) ,
2016-02-24 19:20:48 +00:00
$ mystat { 'Innodb_log_write_requests' }
) if defined $ mystat { 'Innodb_log_write_requests' } ;
debugprint "pct_write_efficiency: " . $ mycalc { 'pct_write_efficiency' } . "" ;
2016-03-29 12:22:45 +00:00
debugprint "Innodb_log_writes: " . $ mystat { 'Innodb_log_writes' } . "" ;
2016-02-24 19:20:48 +00:00
debugprint "Innodb_log_write_requests: "
. $ mystat { 'Innodb_log_write_requests' } . "" ;
2015-08-19 12:45:24 +00:00
$ mycalc { 'pct_innodb_buffer_used' } = percentage (
(
$ mystat { 'Innodb_buffer_pool_pages_total' } -
$ mystat { 'Innodb_buffer_pool_pages_free' }
) ,
$ mystat { 'Innodb_buffer_pool_pages_total' }
) if defined $ mystat { 'Innodb_buffer_pool_pages_total' } ;
# Binlog Cache
if ( $ myvar { 'log_bin' } ne 'OFF' ) {
$ mycalc { 'pct_binlog_cache' } = percentage (
$ mystat { 'Binlog_cache_use' } - $ mystat { 'Binlog_cache_disk_use' } ,
$ mystat { 'Binlog_cache_use' } ) ;
}
2008-09-08 01:16:39 +00:00
}
sub mysql_stats {
2016-04-11 10:01:01 +00:00
subheaderprint "Performance Metrics" ;
2015-08-19 12:45:24 +00:00
# Show uptime, queries per second, connections, traffic stats
my $ qps ;
if ( $ mystat { 'Uptime' } > 0 ) {
$ qps = sprintf ( "%.3f" , $ mystat { 'Questions' } / $ mystat { 'Uptime' } ) ;
}
push ( @ generalrec ,
"MySQL started within last 24 hours - recommendations may be inaccurate"
) if ( $ mystat { 'Uptime' } < 86400 ) ;
infoprint "Up for: "
. pretty_uptime ( $ mystat { 'Uptime' } ) . " ("
. hr_num ( $ mystat { 'Questions' } ) . " q ["
. hr_num ( $ qps )
. " qps], "
. hr_num ( $ mystat { 'Connections' } )
. " conn," . " TX: "
2016-03-02 15:12:38 +00:00
. hr_bytes_rnd ( $ mystat { 'Bytes_sent' } )
2015-08-19 12:45:24 +00:00
. ", RX: "
2016-03-02 15:12:38 +00:00
. hr_bytes_rnd ( $ mystat { 'Bytes_received' } ) . ")" ;
2015-08-19 12:45:24 +00:00
infoprint "Reads / Writes: "
. $ mycalc { 'pct_reads' } . "% / "
. $ mycalc { 'pct_writes' } . "%" ;
# Binlog Cache
if ( $ myvar { 'log_bin' } eq 'OFF' ) {
infoprint "Binary logging is disabled" ;
}
else {
infoprint "Binary logging is enabled (GTID MODE: "
. ( defined ( $ myvar { 'gtid_mode' } ) ? $ myvar { 'gtid_mode' } : "OFF" )
. ")" ;
}
# Memory usage
2016-04-15 10:33:05 +00:00
2016-04-19 14:19:31 +00:00
infoprint "Physical Memory : " . hr_bytes ( $ physical_memory ) ;
infoprint "Max MySQL memory : " . hr_bytes ( $ mycalc { 'max_peak_memory' } ) ;
infoprint "Other process memory: " . hr_bytes ( get_other_process_memory ( ) ) ;
2016-04-15 10:33:05 +00:00
2016-08-09 14:04:13 +00:00
#print hr_bytes( $mycalc{'server_buffers'} );
2015-08-19 12:45:24 +00:00
infoprint "Total buffers: "
. hr_bytes ( $ mycalc { 'server_buffers' } )
. " global + "
. hr_bytes ( $ mycalc { 'per_thread_buffers' } )
. " per thread ($myvar{'max_connections'} max threads)" ;
2016-04-19 14:19:31 +00:00
infoprint "P_S Max memory usage: " . hr_bytes_rnd ( get_pf_memory ( ) ) ;
2016-08-09 14:04:13 +00:00
$ result { 'P_S' } { 'memory' } = get_other_process_memory ( ) ;
$ result { 'P_S' } { 'pretty_memory' } = hr_bytes_rnd ( get_other_process_memory ( ) ) ;
2016-04-19 14:19:31 +00:00
infoprint "Galera GCache Max memory usage: "
. hr_bytes_rnd ( get_gcache_memory ( ) ) ;
2016-08-09 14:04:13 +00:00
$ result { 'Galera' } { 'GCache' } { 'memory' } = get_gcache_memory ( ) ;
$ result { 'Galera' } { 'GCache' } { 'pretty_memory' } = hr_bytes_rnd ( get_gcache_memory ( ) ) ;
2015-08-19 12:45:24 +00:00
if ( $ opt { buffers } ne 0 ) {
infoprint "Global Buffers" ;
infoprint " +-- Key Buffer: "
. hr_bytes ( $ myvar { 'key_buffer_size' } ) . "" ;
infoprint " +-- Max Tmp Table: "
. hr_bytes ( $ mycalc { 'max_tmp_table_size' } ) . "" ;
if ( defined $ myvar { 'query_cache_type' } ) {
infoprint "Query Cache Buffers" ;
2015-11-23 07:08:25 +00:00
infoprint " +-- Query Cache: "
2015-08-19 12:45:24 +00:00
. $ myvar { 'query_cache_type' } . " - "
. (
$ myvar { 'query_cache_type' } eq 0 |
$ myvar { 'query_cache_type' } eq 'OFF' ? "DISABLED"
2016-03-29 12:22:45 +00:00
: (
$ myvar { 'query_cache_type' } eq 1 ? "ALL REQUESTS"
: "ON DEMAND"
)
2015-08-19 12:45:24 +00:00
) . "" ;
infoprint " +-- Query Cache Size: "
. hr_bytes ( $ myvar { 'query_cache_size' } ) . "" ;
}
infoprint "Per Thread Buffers" ;
infoprint " +-- Read Buffer: "
. hr_bytes ( $ myvar { 'read_buffer_size' } ) . "" ;
infoprint " +-- Read RND Buffer: "
. hr_bytes ( $ myvar { 'read_rnd_buffer_size' } ) . "" ;
infoprint " +-- Sort Buffer: "
. hr_bytes ( $ myvar { 'sort_buffer_size' } ) . "" ;
infoprint " +-- Thread stack: "
. hr_bytes ( $ myvar { 'thread_stack' } ) . "" ;
infoprint " +-- Join Buffer: "
. hr_bytes ( $ myvar { 'join_buffer_size' } ) . "" ;
if ( $ myvar { 'log_bin' } ne 'OFF' ) {
infoprint "Binlog Cache Buffers" ;
infoprint " +-- Binlog Cache: "
. hr_bytes ( $ myvar { 'binlog_cache_size' } ) . "" ;
}
}
if ( $ arch
&& $ arch == 32
&& $ mycalc { 'max_used_memory' } > 2 * 1024 * 1024 * 1024 )
{
badprint
2016-03-29 12:22:45 +00:00
"Allocating > 2GB RAM on 32-bit systems can cause system instability" ;
2015-08-19 12:45:24 +00:00
badprint "Maximum reached memory usage: "
. hr_bytes ( $ mycalc { 'max_used_memory' } )
. " ($mycalc{'pct_max_used_memory'}% of installed RAM)" ;
}
elsif ( $ mycalc { 'pct_max_used_memory' } > 85 ) {
badprint "Maximum reached memory usage: "
. hr_bytes ( $ mycalc { 'max_used_memory' } )
. " ($mycalc{'pct_max_used_memory'}% of installed RAM)" ;
}
else {
goodprint "Maximum reached memory usage: "
. hr_bytes ( $ mycalc { 'max_used_memory' } )
. " ($mycalc{'pct_max_used_memory'}% of installed RAM)" ;
}
if ( $ mycalc { 'pct_max_physical_memory' } > 85 ) {
badprint "Maximum possible memory usage: "
. hr_bytes ( $ mycalc { 'max_peak_memory' } )
. " ($mycalc{'pct_max_physical_memory'}% of installed RAM)" ;
push ( @ generalrec ,
"Reduce your overall MySQL memory footprint for system stability" ) ;
}
else {
goodprint "Maximum possible memory usage: "
. hr_bytes ( $ mycalc { 'max_peak_memory' } )
. " ($mycalc{'pct_max_physical_memory'}% of installed RAM)" ;
}
2016-04-19 14:19:31 +00:00
if ( $ physical_memory <
( $ mycalc { 'max_peak_memory' } + get_other_process_memory ( ) ) )
{
badprint
"Overall possible memory usage with other process exceeded memory" ;
push ( @ generalrec ,
2016-06-16 08:33:03 +00:00
"Dedicate this server to your database for highest performance." ) ;
2016-04-19 14:19:31 +00:00
}
else {
goodprint
"Overall possible memory usage with other process is compatible with memory available" ;
}
2016-04-15 10:33:05 +00:00
2015-08-19 12:45:24 +00:00
# Slow queries
if ( $ mycalc { 'pct_slow_queries' } > 5 ) {
badprint "Slow queries: $mycalc{'pct_slow_queries'}% ("
. hr_num ( $ mystat { 'Slow_queries' } ) . "/"
. hr_num ( $ mystat { 'Questions' } ) . ")" ;
}
else {
goodprint "Slow queries: $mycalc{'pct_slow_queries'}% ("
. hr_num ( $ mystat { 'Slow_queries' } ) . "/"
. hr_num ( $ mystat { 'Questions' } ) . ")" ;
}
if ( $ myvar { 'long_query_time' } > 10 ) {
push ( @ adjvars , "long_query_time (<= 10)" ) ;
}
if ( defined ( $ myvar { 'log_slow_queries' } ) ) {
if ( $ myvar { 'log_slow_queries' } eq "OFF" ) {
push ( @ generalrec ,
"Enable the slow query log to troubleshoot bad queries" ) ;
}
}
# Connections
if ( $ mycalc { 'pct_connections_used' } > 85 ) {
badprint
"Highest connection usage: $mycalc{'pct_connections_used'}% ($mystat{'Max_used_connections'}/$myvar{'max_connections'})" ;
push ( @ adjvars ,
"max_connections (> " . $ myvar { 'max_connections' } . ")" ) ;
push ( @ adjvars ,
"wait_timeout (< " . $ myvar { 'wait_timeout' } . ")" ,
"interactive_timeout (< " . $ myvar { 'interactive_timeout' } . ")" ) ;
push ( @ generalrec ,
"Reduce or eliminate persistent connections to reduce connection usage"
) ;
}
else {
goodprint
"Highest usage of available connections: $mycalc{'pct_connections_used'}% ($mystat{'Max_used_connections'}/$myvar{'max_connections'})" ;
}
# Aborted Connections
if ( $ mycalc { 'pct_connections_aborted' } > 3 ) {
badprint
"Aborted connections: $mycalc{'pct_connections_aborted'}% ($mystat{'Aborted_connects'}/$mystat{'Connections'})" ;
push ( @ generalrec ,
"Reduce or eliminate unclosed connections and network issues" ) ;
}
else {
goodprint
"Aborted connections: $mycalc{'pct_connections_aborted'}% ($mystat{'Aborted_connects'}/$mystat{'Connections'})" ;
}
2016-06-03 06:33:02 +00:00
# name resolution
2016-08-25 14:33:58 +00:00
if ( not defined ( $ result { 'Variables' } { 'skip_name_resolve' } ) ) {
infoprint "Skipped name resolution test due to missing skip_name_resolve in system variables. ?More info?" ;
} elsif ( $ result { 'Variables' } { 'skip_name_resolve' } eq 'OFF' ) {
2016-06-03 06:33:02 +00:00
badprint
"name resolution is active : a reverse name resolution is made for each new connection and can reduce performance" ;
push ( @ generalrec ,
"Configure your accounts with ip or subnets only, then update your configuration with skip-name-resolve=1" ) ;
}
2015-08-19 12:45:24 +00:00
# Query cache
if ( ! mysql_version_ge ( 4 ) ) {
# MySQL versions < 4.01 don't support query caching
push ( @ generalrec ,
"Upgrade MySQL to version 4+ to utilize query caching" ) ;
}
2016-04-21 07:06:13 +00:00
elsif ( mysql_version_ge ( 5 , 5 ) and ! mysql_version_ge ( 10 , 1 ) ) {
2016-03-29 12:22:45 +00:00
if ( $ myvar { 'query_cache_type' } ne "OFF" ) {
badprint
2016-04-29 12:01:15 +00:00
"Query cache may be disabled by default due to mutex contention." ;
2016-03-29 12:22:45 +00:00
push ( @ adjvars , "query_cache_type (=0)" ) ;
}
else {
goodprint
2016-04-29 12:01:15 +00:00
"Query cache is disabled by default due to mutex contention on multiprocessor machines." ;
2016-03-29 12:22:45 +00:00
}
2016-03-16 15:53:30 +00:00
}
2015-08-19 12:45:24 +00:00
elsif ( $ myvar { 'query_cache_size' } < 1 ) {
badprint "Query cache is disabled" ;
push ( @ adjvars , "query_cache_size (>= 8M)" ) ;
}
elsif ( $ myvar { 'query_cache_type' } eq "OFF" ) {
badprint "Query cache is disabled" ;
push ( @ adjvars , "query_cache_type (=1)" ) ;
}
elsif ( $ mystat { 'Com_select' } == 0 ) {
badprint
"Query cache cannot be analyzed - no SELECT statements executed" ;
}
else {
if ( $ mycalc { 'query_cache_efficiency' } < 20 ) {
badprint
"Query cache efficiency: $mycalc{'query_cache_efficiency'}% ("
. hr_num ( $ mystat { 'Qcache_hits' } )
. " cached / "
. hr_num ( $ mystat { 'Qcache_hits' } + $ mystat { 'Com_select' } )
. " selects)" ;
push ( @ adjvars ,
"query_cache_limit (> "
. hr_bytes_rnd ( $ myvar { 'query_cache_limit' } )
. ", or use smaller result sets)" ) ;
}
else {
goodprint
"Query cache efficiency: $mycalc{'query_cache_efficiency'}% ("
. hr_num ( $ mystat { 'Qcache_hits' } )
. " cached / "
. hr_num ( $ mystat { 'Qcache_hits' } + $ mystat { 'Com_select' } )
. " selects)" ;
}
if ( $ mycalc { 'query_cache_prunes_per_day' } > 98 ) {
badprint
"Query cache prunes per day: $mycalc{'query_cache_prunes_per_day'}" ;
if ( $ myvar { 'query_cache_size' } >= 128 * 1024 * 1024 ) {
push ( @ generalrec ,
"Increasing the query_cache size over 128M may reduce performance"
) ;
push ( @ adjvars ,
"query_cache_size (> "
. hr_bytes_rnd ( $ myvar { 'query_cache_size' } )
. ") [see warning above]" ) ;
}
else {
push ( @ adjvars ,
"query_cache_size (> "
. hr_bytes_rnd ( $ myvar { 'query_cache_size' } )
. ")" ) ;
}
}
else {
goodprint
"Query cache prunes per day: $mycalc{'query_cache_prunes_per_day'}" ;
}
}
# Sorting
if ( $ mycalc { 'total_sorts' } == 0 ) {
2016-04-19 14:19:31 +00:00
goodprint "No Sort requiring temporary tables" ;
2015-08-19 12:45:24 +00:00
}
elsif ( $ mycalc { 'pct_temp_sort_table' } > 10 ) {
badprint
"Sorts requiring temporary tables: $mycalc{'pct_temp_sort_table'}% ("
. hr_num ( $ mystat { 'Sort_merge_passes' } )
. " temp sorts / "
. hr_num ( $ mycalc { 'total_sorts' } )
. " sorts)" ;
push ( @ adjvars ,
"sort_buffer_size (> "
. hr_bytes_rnd ( $ myvar { 'sort_buffer_size' } )
. ")" ) ;
push ( @ adjvars ,
"read_rnd_buffer_size (> "
. hr_bytes_rnd ( $ myvar { 'read_rnd_buffer_size' } )
. ")" ) ;
}
else {
goodprint
"Sorts requiring temporary tables: $mycalc{'pct_temp_sort_table'}% ("
. hr_num ( $ mystat { 'Sort_merge_passes' } )
. " temp sorts / "
. hr_num ( $ mycalc { 'total_sorts' } )
. " sorts)" ;
}
# Joins
if ( $ mycalc { 'joins_without_indexes_per_day' } > 250 ) {
badprint
"Joins performed without indexes: $mycalc{'joins_without_indexes'}" ;
push ( @ adjvars ,
"join_buffer_size (> "
. hr_bytes ( $ myvar { 'join_buffer_size' } )
. ", or always use indexes with joins)" ) ;
push ( @ generalrec ,
"Adjust your join queries to always utilize indexes" ) ;
}
else {
2016-04-19 14:19:31 +00:00
goodprint "No joins without indexes" ;
2015-08-19 12:45:24 +00:00
# No joins have run without indexes
}
# Temporary tables
if ( $ mystat { 'Created_tmp_tables' } > 0 ) {
if ( $ mycalc { 'pct_temp_disk' } > 25
&& $ mycalc { 'max_tmp_table_size' } < 256 * 1024 * 1024 )
{
badprint
"Temporary tables created on disk: $mycalc{'pct_temp_disk'}% ("
. hr_num ( $ mystat { 'Created_tmp_disk_tables' } )
. " on disk / "
. hr_num ( $ mystat { 'Created_tmp_tables' } )
. " total)" ;
push ( @ adjvars ,
"tmp_table_size (> "
. hr_bytes_rnd ( $ myvar { 'tmp_table_size' } )
. ")" ) ;
push ( @ adjvars ,
"max_heap_table_size (> "
. hr_bytes_rnd ( $ myvar { 'max_heap_table_size' } )
. ")" ) ;
push ( @ generalrec ,
"When making adjustments, make tmp_table_size/max_heap_table_size equal"
) ;
push ( @ generalrec ,
2016-03-29 12:22:45 +00:00
"Reduce your SELECT DISTINCT queries which have no LIMIT clause"
) ;
2015-08-19 12:45:24 +00:00
}
elsif ( $ mycalc { 'pct_temp_disk' } > 25
&& $ mycalc { 'max_tmp_table_size' } >= 256 * 1024 * 1024 )
{
badprint
"Temporary tables created on disk: $mycalc{'pct_temp_disk'}% ("
. hr_num ( $ mystat { 'Created_tmp_disk_tables' } )
. " on disk / "
. hr_num ( $ mystat { 'Created_tmp_tables' } )
. " total)" ;
push ( @ generalrec ,
"Temporary table size is already large - reduce result set size"
) ;
push ( @ generalrec ,
"Reduce your SELECT DISTINCT queries without LIMIT clauses" ) ;
}
else {
goodprint
"Temporary tables created on disk: $mycalc{'pct_temp_disk'}% ("
. hr_num ( $ mystat { 'Created_tmp_disk_tables' } )
. " on disk / "
. hr_num ( $ mystat { 'Created_tmp_tables' } )
. " total)" ;
}
}
else {
2016-04-19 14:19:31 +00:00
goodprint "No tmp tables created on disk" ;
2015-08-19 12:45:24 +00:00
}
# Thread cache
2016-08-30 11:45:46 +00:00
if ( $ myvar { 'thread_cache_size' } eq 0 ) {
badprint "Thread cache is disabled" ;
push ( @ generalrec , "Set thread_cache_size to 4 as a starting value" ) ;
push ( @ adjvars , "thread_cache_size (start at 4)" ) ;
} else {
2016-08-30 12:48:48 +00:00
if ( defined ( $ myvar { 'thread_handling' } ) and $ myvar { 'thread_handling' } eq 'pools-of-threads' ) {
2016-08-30 11:45:46 +00:00
infoprint "Thread cache hit rate: not used with pool-of-threads" ;
} else {
if ( $ mycalc { 'thread_cache_hit_rate' } <= 50 ) {
badprint
"Thread cache hit rate: $mycalc{'thread_cache_hit_rate'}% ("
. hr_num ( $ mystat { 'Threads_created' } )
. " created / "
. hr_num ( $ mystat { 'Connections' } )
. " connections)" ;
push ( @ adjvars ,
"thread_cache_size (> $myvar{'thread_cache_size'})" ) ;
} else {
goodprint
"Thread cache hit rate: $mycalc{'thread_cache_hit_rate'}% ("
. hr_num ( $ mystat { 'Threads_created' } )
. " created / "
. hr_num ( $ mystat { 'Connections' } )
. " connections)" ;
}
}
}
2015-08-19 12:45:24 +00:00
# Table cache
my $ table_cache_var = "" ;
if ( $ mystat { 'Open_tables' } > 0 ) {
if ( $ mycalc { 'table_cache_hit_rate' } < 20 ) {
badprint "Table cache hit rate: $mycalc{'table_cache_hit_rate'}% ("
. hr_num ( $ mystat { 'Open_tables' } )
. " open / "
. hr_num ( $ mystat { 'Opened_tables' } )
. " opened)" ;
if ( mysql_version_ge ( 5 , 1 ) ) {
$ table_cache_var = "table_open_cache" ;
}
else {
$ table_cache_var = "table_cache" ;
}
push ( @ adjvars ,
$ table_cache_var . " (> " . $ myvar { $ table_cache_var } . ")" ) ;
push ( @ generalrec ,
"Increase "
. $ table_cache_var
. " gradually to avoid file descriptor limits" ) ;
push ( @ generalrec ,
"Read this before increasing "
. $ table_cache_var
. " over 64: http://bit.ly/1mi7c4C" ) ;
push ( @ generalrec ,
"Beware that open_files_limit ("
. $ myvar { 'open_files_limit' }
. ") variable " ) ;
push ( @ generalrec ,
2015-08-24 07:51:03 +00:00
"should be greater than $table_cache_var ( "
2015-08-19 12:45:24 +00:00
. $ myvar { $ table_cache_var }
. ")" ) ;
}
else {
goodprint "Table cache hit rate: $mycalc{'table_cache_hit_rate'}% ("
. hr_num ( $ mystat { 'Open_tables' } )
. " open / "
. hr_num ( $ mystat { 'Opened_tables' } )
. " opened)" ;
}
}
# Open files
if ( defined $ mycalc { 'pct_files_open' } ) {
if ( $ mycalc { 'pct_files_open' } > 85 ) {
badprint "Open file limit used: $mycalc{'pct_files_open'}% ("
. hr_num ( $ mystat { 'Open_files' } ) . "/"
. hr_num ( $ myvar { 'open_files_limit' } ) . ")" ;
push ( @ adjvars ,
"open_files_limit (> " . $ myvar { 'open_files_limit' } . ")" ) ;
}
else {
goodprint "Open file limit used: $mycalc{'pct_files_open'}% ("
. hr_num ( $ mystat { 'Open_files' } ) . "/"
. hr_num ( $ myvar { 'open_files_limit' } ) . ")" ;
}
}
# Table locks
if ( defined $ mycalc { 'pct_table_locks_immediate' } ) {
if ( $ mycalc { 'pct_table_locks_immediate' } < 95 ) {
badprint
"Table locks acquired immediately: $mycalc{'pct_table_locks_immediate'}%" ;
push ( @ generalrec ,
"Optimize queries and/or use InnoDB to reduce lock wait" ) ;
}
else {
goodprint
"Table locks acquired immediately: $mycalc{'pct_table_locks_immediate'}% ("
. hr_num ( $ mystat { 'Table_locks_immediate' } )
. " immediate / "
. hr_num ( $ mystat { 'Table_locks_waited' } +
$ mystat { 'Table_locks_immediate' } )
. " locks)" ;
}
}
# Binlog cache
if ( defined $ mycalc { 'pct_binlog_cache' } ) {
if ( $ mycalc { 'pct_binlog_cache' } < 90
&& $ mystat { 'Binlog_cache_use' } > 0 )
{
badprint "Binlog cache memory access: "
. $ mycalc { 'pct_binlog_cache' } . "% ( "
. (
$ mystat { 'Binlog_cache_use' } - $ mystat { 'Binlog_cache_disk_use' } )
. " Memory / "
. $ mystat { 'Binlog_cache_use' }
. " Total)" ;
push ( @ generalrec ,
"Increase binlog_cache_size (Actual value: "
. $ myvar { 'binlog_cache_size' }
. ") " ) ;
push ( @ adjvars ,
"binlog_cache_size ("
. hr_bytes ( $ myvar { 'binlog_cache_size' } + 16 * 1024 * 1024 )
. " ) " ) ;
}
else {
goodprint "Binlog cache memory access: "
. $ mycalc { 'pct_binlog_cache' } . "% ( "
. (
$ mystat { 'Binlog_cache_use' } - $ mystat { 'Binlog_cache_disk_use' } )
. " Memory / "
. $ mystat { 'Binlog_cache_use' }
. " Total)" ;
2016-04-22 15:22:00 +00:00
debugprint "Not enough data to validate binlog cache size\n"
2015-08-19 12:45:24 +00:00
if $ mystat { 'Binlog_cache_use' } < 10 ;
}
}
# Performance options
if ( ! mysql_version_ge ( 5 , 1 ) ) {
2016-04-22 15:22:00 +00:00
push ( @ generalrec , "Upgrade to MySQL 5.5+ to use asynchronous write" ) ;
2015-08-19 12:45:24 +00:00
}
elsif ( $ myvar { 'concurrent_insert' } eq "OFF" ) {
push ( @ generalrec , "Enable concurrent_insert by setting it to 'ON'" ) ;
}
elsif ( $ myvar { 'concurrent_insert' } eq 0 ) {
push ( @ generalrec , "Enable concurrent_insert by setting it to 1" ) ;
}
}
2015-12-10 10:52:39 +00:00
# Recommendations for MyISAM
2015-08-19 12:45:24 +00:00
sub mysql_myisam {
2016-04-11 10:01:01 +00:00
subheaderprint "MyISAM Metrics" ;
2016-03-29 12:22:45 +00:00
2015-08-19 12:45:24 +00:00
# Key buffer usage
if ( defined ( $ mycalc { 'pct_key_buffer_used' } ) ) {
if ( $ mycalc { 'pct_key_buffer_used' } < 90 ) {
badprint "Key buffer used: $mycalc{'pct_key_buffer_used'}% ("
. hr_num ( $ myvar { 'key_buffer_size' } *
$ mycalc { 'pct_key_buffer_used' } /
100 )
. " used / "
. hr_num ( $ myvar { 'key_buffer_size' } )
. " cache)" ;
#push(@adjvars,"key_buffer_size (\~ ".hr_num( $myvar{'key_buffer_size'} * $mycalc{'pct_key_buffer_used'} / 100).")");
}
else {
goodprint "Key buffer used: $mycalc{'pct_key_buffer_used'}% ("
. hr_num ( $ myvar { 'key_buffer_size' } *
$ mycalc { 'pct_key_buffer_used' } /
100 )
. " used / "
. hr_num ( $ myvar { 'key_buffer_size' } )
. " cache)" ;
}
}
else {
# No queries have run that would use keys
debugprint "Key buffer used: $mycalc{'pct_key_buffer_used'}% ("
. hr_num (
$ myvar { 'key_buffer_size' } * $ mycalc { 'pct_key_buffer_used' } / 100 )
. " used / "
. hr_num ( $ myvar { 'key_buffer_size' } )
. " cache)" ;
2015-11-23 07:08:25 +00:00
}
2015-08-19 12:45:24 +00:00
# Key buffer
if ( ! defined ( $ mycalc { 'total_myisam_indexes' } ) and $ doremote == 1 ) {
push ( @ generalrec ,
"Unable to calculate MyISAM indexes on remote MySQL server < 5.0.0"
) ;
}
elsif ( $ mycalc { 'total_myisam_indexes' } =~ /^fail$/ ) {
badprint
"Cannot calculate MyISAM index size - re-run script as root user" ;
}
elsif ( $ mycalc { 'total_myisam_indexes' } == "0" ) {
badprint
"None of your MyISAM tables are indexed - add indexes immediately" ;
}
else {
if ( $ myvar { 'key_buffer_size' } < $ mycalc { 'total_myisam_indexes' }
&& $ mycalc { 'pct_keys_from_mem' } < 95 )
{
badprint "Key buffer size / total MyISAM indexes: "
. hr_bytes ( $ myvar { 'key_buffer_size' } ) . "/"
. hr_bytes ( $ mycalc { 'total_myisam_indexes' } ) . "" ;
push ( @ adjvars ,
"key_buffer_size (> "
. hr_bytes ( $ mycalc { 'total_myisam_indexes' } )
. ")" ) ;
}
else {
goodprint "Key buffer size / total MyISAM indexes: "
. hr_bytes ( $ myvar { 'key_buffer_size' } ) . "/"
. hr_bytes ( $ mycalc { 'total_myisam_indexes' } ) . "" ;
}
if ( $ mystat { 'Key_read_requests' } > 0 ) {
if ( $ mycalc { 'pct_keys_from_mem' } < 95 ) {
badprint
"Read Key buffer hit rate: $mycalc{'pct_keys_from_mem'}% ("
. hr_num ( $ mystat { 'Key_read_requests' } )
. " cached / "
. hr_num ( $ mystat { 'Key_reads' } )
. " reads)" ;
}
else {
goodprint
"Read Key buffer hit rate: $mycalc{'pct_keys_from_mem'}% ("
. hr_num ( $ mystat { 'Key_read_requests' } )
. " cached / "
. hr_num ( $ mystat { 'Key_reads' } )
. " reads)" ;
}
}
else {
# No queries have run that would use keys
debugprint "Key buffer size / total MyISAM indexes: "
. hr_bytes ( $ myvar { 'key_buffer_size' } ) . "/"
. hr_bytes ( $ mycalc { 'total_myisam_indexes' } ) . "" ;
}
if ( $ mystat { 'Key_write_requests' } > 0 ) {
if ( $ mycalc { 'pct_wkeys_from_mem' } < 95 ) {
badprint
"Write Key buffer hit rate: $mycalc{'pct_wkeys_from_mem'}% ("
. hr_num ( $ mystat { 'Key_write_requests' } )
. " cached / "
. hr_num ( $ mystat { 'Key_writes' } )
. " writes)" ;
}
else {
goodprint
"Write Key buffer hit rate: $mycalc{'pct_wkeys_from_mem'}% ("
. hr_num ( $ mystat { 'Key_write_requests' } )
. " cached / "
. hr_num ( $ mystat { 'Key_writes' } )
. " writes)" ;
}
}
else {
# No queries have run that would use keys
debugprint
"Write Key buffer hit rate: $mycalc{'pct_wkeys_from_mem'}% ("
. hr_num ( $ mystat { 'Key_write_requests' } )
. " cached / "
. hr_num ( $ mystat { 'Key_writes' } )
. " writes)" ;
}
}
}
2011-03-08 18:38:37 +00:00
2016-01-27 18:00:27 +00:00
# Recommendations for ThreadPool
sub mariadb_threadpool {
2016-04-11 10:01:01 +00:00
subheaderprint "ThreadPool Metrics" ;
2016-01-27 18:00:27 +00:00
# AriaDB
unless ( defined $ myvar { 'have_threadpool' }
2016-03-22 14:20:18 +00:00
&& $ myvar { 'have_threadpool' } eq "YES" )
2016-01-27 18:00:27 +00:00
{
infoprint "ThreadPool stat is disabled." ;
return ;
}
2016-03-29 12:22:45 +00:00
infoprint "ThreadPool stat is enabled." ;
infoprint "Thread Pool Size: " . $ myvar { 'thread_pool_size' } . " thread(s)." ;
2016-03-22 14:20:18 +00:00
2016-04-19 14:19:31 +00:00
if ( $ myvar { 'version' } =~ /mariadb|percona/i ) {
2016-04-22 15:22:00 +00:00
infoprint "Using default value is good enough for your version ("
2016-04-19 14:19:31 +00:00
. $ myvar { 'version' } . ")" ;
return ;
}
2016-03-22 14:20:18 +00:00
2016-03-29 12:22:45 +00:00
if ( $ myvar { 'have_innodb' } eq 'YES' ) {
if ( $ myvar { 'thread_pool_size' } < 16
or $ myvar { 'thread_pool_size' } > 36 )
{
badprint
"thread_pool_size between 16 and 36 when using InnoDB storage engine." ;
push ( @ generalrec ,
"Thread pool size for InnoDB usage ("
. $ myvar { 'thread_pool_size' }
. ")" ) ;
push ( @ adjvars ,
"thread_pool_size between 16 and 36 for InnoDB usage" ) ;
}
else {
goodprint
"thread_pool_size between 16 and 36 when using InnoDB storage engine." ;
2016-03-22 14:20:18 +00:00
}
return ;
2016-03-29 12:22:45 +00:00
}
if ( $ myvar { 'have_isam' } eq 'YES' ) {
if ( $ myvar { 'thread_pool_size' } < 4 or $ myvar { 'thread_pool_size' } > 8 )
{
badprint
"thread_pool_size between 4 and 8 when using MyIsam storage engine." ;
push ( @ generalrec ,
"Thread pool size for MyIsam usage ("
. $ myvar { 'thread_pool_size' }
. ")" ) ;
push ( @ adjvars ,
"thread_pool_size between 4 and 8 for MyIsam usage" ) ;
}
else {
goodprint
"thread_pool_size between 4 and 8 when using MyISAM storage engine." ;
2016-03-22 14:20:18 +00:00
}
}
2016-01-27 18:00:27 +00:00
}
2016-04-19 14:19:31 +00:00
sub get_pf_memory {
2016-04-11 10:01:01 +00:00
# Performance Schema
2016-04-18 09:07:05 +00:00
return 0 unless defined $ myvar { 'performance_schema' } ;
return 0 if $ myvar { 'performance_schema' } eq 'OFF' ;
2016-04-19 14:19:31 +00:00
my @ infoPFSMemory = grep /performance_schema.memory/ ,
select_array ( "SHOW ENGINE PERFORMANCE_SCHEMA STATUS" ) ;
return 0 if scalar ( @ infoPFSMemory ) == 0 ;
2016-04-05 15:40:38 +00:00
$ infoPFSMemory [ 0 ] =~ s/.*\s+(\d+)$/$1/g ;
return $ infoPFSMemory [ 0 ] ;
}
2016-04-19 14:19:31 +00:00
2016-03-16 17:40:44 +00:00
# Recommendations for Performance Schema
sub mysqsl_pfs {
2016-04-11 10:01:01 +00:00
subheaderprint "Performance schema" ;
2016-03-16 17:40:44 +00:00
# Performance Schema
2016-03-29 12:22:45 +00:00
unless ( defined ( $ myvar { 'performance_schema' } )
and $ myvar { 'performance_schema' } eq 'ON' )
{
infoprint "Performance schema is disabled." ;
2016-04-21 21:16:35 +00:00
return ;
2016-03-29 12:22:45 +00:00
}
2016-06-16 09:07:32 +00:00
infoprint "Performance schema is enabled." ;
2016-04-19 14:19:31 +00:00
infoprint "Memory used by P_S: " . hr_bytes ( get_pf_memory ( ) ) ;
2016-04-21 21:16:35 +00:00
if ( grep /^sys$/ , select_array ( "SHOW DATABASES" ) ) {
infoprint "Sys schema is installed." ;
} else {
infoprint "Sys schema isn't installed." ;
return ;
}
2016-06-16 09:07:32 +00:00
2016-03-16 17:40:44 +00:00
}
2015-12-10 10:52:39 +00:00
# Recommendations for Ariadb
2016-01-27 13:50:29 +00:00
sub mariadb_ariadb {
2016-04-11 10:01:01 +00:00
subheaderprint "AriaDB Metrics" ;
2015-08-19 12:45:24 +00:00
# AriaDB
unless ( defined $ myvar { 'have_aria' }
2016-04-05 16:25:20 +00:00
and $ myvar { 'have_aria' } eq "YES" )
2015-08-19 12:45:24 +00:00
{
infoprint "AriaDB is disabled." ;
return ;
}
infoprint "AriaDB is enabled." ;
# Aria pagecache
if ( ! defined ( $ mycalc { 'total_aria_indexes' } ) and $ doremote == 1 ) {
push ( @ generalrec ,
"Unable to calculate Aria indexes on remote MySQL server < 5.0.0" ) ;
}
elsif ( $ mycalc { 'total_aria_indexes' } =~ /^fail$/ ) {
badprint
"Cannot calculate Aria index size - re-run script as root user" ;
}
elsif ( $ mycalc { 'total_aria_indexes' } == "0" ) {
badprint
"None of your Aria tables are indexed - add indexes immediately" ;
}
else {
if (
$ myvar { 'aria_pagecache_buffer_size' } < $ mycalc { 'total_aria_indexes' }
&& $ mycalc { 'pct_aria_keys_from_mem' } < 95 )
{
badprint "Aria pagecache size / total Aria indexes: "
. hr_bytes ( $ myvar { 'aria_pagecache_buffer_size' } ) . "/"
. hr_bytes ( $ mycalc { 'total_aria_indexes' } ) . "" ;
push ( @ adjvars ,
"aria_pagecache_buffer_size (> "
. hr_bytes ( $ mycalc { 'total_aria_indexes' } )
. ")" ) ;
}
else {
goodprint "Aria pagecache size / total Aria indexes: "
. hr_bytes ( $ myvar { 'aria_pagecache_buffer_size' } ) . "/"
. hr_bytes ( $ mycalc { 'total_aria_indexes' } ) . "" ;
}
if ( $ mystat { 'Aria_pagecache_read_requests' } > 0 ) {
if ( $ mycalc { 'pct_aria_keys_from_mem' } < 95 ) {
badprint
"Aria pagecache hit rate: $mycalc{'pct_aria_keys_from_mem'}% ("
. hr_num ( $ mystat { 'Aria_pagecache_read_requests' } )
. " cached / "
. hr_num ( $ mystat { 'Aria_pagecache_reads' } )
. " reads)" ;
}
else {
goodprint
"Aria pagecache hit rate: $mycalc{'pct_aria_keys_from_mem'}% ("
. hr_num ( $ mystat { 'Aria_pagecache_read_requests' } )
. " cached / "
. hr_num ( $ mystat { 'Aria_pagecache_reads' } )
. " reads)" ;
}
}
else {
# No queries have run that would use keys
}
}
2015-06-18 08:56:47 +00:00
}
2015-08-19 12:45:24 +00:00
2016-01-27 13:50:29 +00:00
# Recommendations for TokuDB
sub mariadb_tokudb {
2016-04-11 10:01:01 +00:00
subheaderprint "TokuDB Metrics" ;
2016-01-27 13:50:29 +00:00
# AriaDB
unless ( defined $ myvar { 'have_tokudb' }
2016-06-10 08:27:55 +00:00
&& $ myvar { 'have_tokudb' } eq "YES" )
2016-01-27 13:50:29 +00:00
{
infoprint "TokuDB is disabled." ;
return ;
}
infoprint "TokuDB is enabled." ;
# All is to done here
}
2016-04-04 15:23:43 +00:00
# Perl trim function to remove whitespace from the start and end of the string
sub trim {
2016-04-19 14:19:31 +00:00
my $ string = shift ;
$ string =~ s/^\s+// ;
$ string =~ s/\s+$// ;
return $ string ;
2016-04-04 15:23:43 +00:00
}
2016-04-05 16:25:20 +00:00
sub get_wsrep_options {
2016-04-19 14:19:31 +00:00
return ( ) unless defined $ myvar { 'wsrep_provider_options' } ;
2016-04-05 16:25:20 +00:00
2016-04-19 14:19:31 +00:00
my @ galera_options = split /;/ , $ myvar { 'wsrep_provider_options' } ;
2016-04-05 16:25:20 +00:00
remove_cr @ galera_options ;
2016-04-19 14:19:31 +00:00
@ galera_options = remove_empty @ galera_options ;
debugprint Dumper ( \ @ galera_options ) ;
2016-04-05 16:25:20 +00:00
return @ galera_options ;
}
2016-04-19 14:19:31 +00:00
2016-04-05 16:25:20 +00:00
sub get_gcache_memory {
2016-04-19 14:19:31 +00:00
my $ gCacheMem = get_wsrep_option ( 'gcache.mem_size' ) ;
2016-04-18 08:59:50 +00:00
return 0 unless defined $ gCacheMem and $ gCacheMem ne '' ;
return $ gCacheMem ;
2016-04-15 14:17:56 +00:00
}
2016-04-19 14:19:31 +00:00
2016-04-15 14:17:56 +00:00
sub get_wsrep_option {
2016-04-19 14:19:31 +00:00
my $ key = shift ;
return '' unless defined $ myvar { 'wsrep_provider_options' } ;
my @ galera_options = get_wsrep_options ;
return '' unless scalar ( @ galera_options ) > 0 ;
my @ memValues = grep /\s*$key =/ , @ galera_options ;
my $ memValue = $ memValues [ 0 ] ;
2016-04-15 14:17:56 +00:00
$ memValue =~ s/.*=\s*(.+)$/$1/g ;
2016-04-05 16:25:20 +00:00
return $ memValue ;
}
2016-04-15 14:17:56 +00:00
2016-01-27 13:50:29 +00:00
# Recommendations for Galera
sub mariadb_galera {
2016-04-11 10:01:01 +00:00
subheaderprint "Galera Metrics" ;
2016-01-27 13:50:29 +00:00
2016-04-05 16:25:20 +00:00
# Galera Cluster
2016-01-27 13:50:29 +00:00
unless ( defined $ myvar { 'have_galera' }
2016-04-04 15:23:43 +00:00
&& $ myvar { 'have_galera' } eq "YES" )
2016-01-27 13:50:29 +00:00
{
infoprint "Galera is disabled." ;
return ;
}
infoprint "Galera is enabled." ;
2016-04-19 14:19:31 +00:00
debugprint "Galera variables:" ;
2016-04-04 15:30:16 +00:00
foreach my $ gvar ( keys % myvar ) {
2016-04-19 14:19:31 +00:00
next unless $ gvar =~ /^wsrep.*/ ;
next if $ gvar eq 'wsrep_provider_options' ;
debugprint "\t" . trim ( $ gvar ) . " = " . $ myvar { $ gvar } ;
2016-08-09 14:04:13 +00:00
$ result { 'Galera' } { 'variables' } { $ gvar } = $ myvar { $ gvar } ;
2016-04-04 15:30:16 +00:00
}
2016-03-29 12:22:45 +00:00
2016-04-19 14:19:31 +00:00
debugprint "Galera wsrep provider Options:" ;
my @ galera_options = get_wsrep_options ;
2016-08-09 14:04:13 +00:00
$ result { 'Galera' } { 'wsrep options' } = get_wsrep_options ( ) ;
2016-04-19 14:19:31 +00:00
foreach my $ gparam ( @ galera_options ) {
debugprint "\t" . trim ( $ gparam ) ;
2016-04-04 15:23:43 +00:00
}
2016-04-19 14:19:31 +00:00
debugprint "Galera status:" ;
2016-04-04 15:23:43 +00:00
foreach my $ gstatus ( keys % mystat ) {
2016-04-19 14:19:31 +00:00
next unless $ gstatus =~ /^wsrep.*/ ;
debugprint "\t" . trim ( $ gstatus ) . " = " . $ mystat { $ gstatus } ;
2016-08-09 14:04:13 +00:00
$ result { 'Galera' } { 'status' } { $ gstatus } = $ myvar { $ gstatus } ;
2016-04-19 14:19:31 +00:00
}
infoprint "GCache is using "
. hr_bytes_rnd ( get_wsrep_option ( 'gcache.mem_size' ) ) ;
my @ primaryKeysNbTables = select_array (
2016-08-10 09:44:22 +00:00
" Select CONCAT ( c . table_schema , CONCAT ( '.' , c . table_name ) )
from information_schema . columns c
join information_schema . tables t using ( TABLE_SCHEMA , TABLE_NAME )
where c . table_schema not in ( 'mysql' , 'information_schema' , 'performance_schema' )
and t . table_type != 'VIEW'
group by c . table_schema , c . table_name
having sum ( if ( c . column_key in ( 'PRI' , 'UNI' ) , 1 , 0 ) ) = 0 "
) ;
2016-04-19 14:19:31 +00:00
if ( scalar ( @ primaryKeysNbTables ) > 0 ) {
badprint "Following table(s) don't have primary key:" ;
foreach my $ badtable ( @ primaryKeysNbTables ) {
badprint "\t$badtable" ;
2016-08-09 14:04:13 +00:00
push @ { $ result { 'Tables without PK' } } , $ badtable ;
2016-04-19 14:19:31 +00:00
}
}
else {
goodprint "All tables get a primary key" ;
}
my @ nonInnoDbTables = select_array (
"select CONCAT(table_schema,CONCAT('.', table_name)) from information_schema.tables where ENGINE <> 'InnoDb' and table_schema not in ('mysql', 'performance_schema', 'information_schema')"
) ;
if ( scalar ( @ nonInnoDbTables ) > 0 ) {
badprint "Following table(s) are not InnoDB table:" ;
push @ generalrec ,
2016-04-22 15:22:00 +00:00
"Ensure that all table(s) are InnoDB tables for Galera replication" ;
2016-04-19 14:19:31 +00:00
foreach my $ badtable ( @ nonInnoDbTables ) {
badprint "\t$badtable" ;
}
}
else {
goodprint "All tables are InnoDB tables" ;
}
if ( $ myvar { 'binlog_format' } ne 'ROW' ) {
badprint "Binlog format should be in ROW mode." ;
push @ adjvars , "binlog_format = ROW" ;
}
else {
goodprint "Binlog format is in ROW mode." ;
}
if ( $ myvar { 'innodb_flush_log_at_trx_commit' } != 0 ) {
badprint "Innodb flush log at each commit should be disabled." ;
push @ adjvars , "innodb_flush_log_at_trx_commit = 0" ;
}
else {
goodprint "Innodb flush log at each commit is disabled for Galera." ;
}
infoprint "Read consistency mode :" . $ myvar { 'wsrep_causal_reads' } ;
if ( defined ( $ myvar { 'wsrep_cluster_name' } )
and $ myvar { 'wsrep_on' } eq "ON" )
{
goodprint "Galera WsREP is enabled." ;
if ( defined ( $ myvar { 'wsrep_cluster_address' } )
and trim ( "$myvar{'wsrep_cluster_address'}" ) ne "" )
{
goodprint "Galera Cluster address is defined: "
. $ myvar { 'wsrep_cluster_address' } ;
2016-05-19 15:10:48 +00:00
my @ NodesTmp = split /,/ , $ myvar { 'wsrep_cluster_address' } ;
my $ nbNodes = @ NodesTmp ;
2016-04-27 10:42:50 +00:00
infoprint "There are $nbNodes nodes in wsrep_cluster_address" ;
2016-04-19 14:19:31 +00:00
my $ nbNodesSize = trim ( $ mystat { 'wsrep_cluster_size' } ) ;
2016-04-27 10:42:50 +00:00
if ( $ nbNodesSize == 3 or $ nbNodesSize == 5 ) {
goodprint "There are $nbNodesSize nodes in wsrep_cluster_size." ;
2016-04-19 14:19:31 +00:00
}
else {
badprint
2016-04-27 10:42:50 +00:00
"There are $nbNodesSize nodes in wsrep_cluster_size. Prefer 3 or 5 nodes architecture." ;
2016-04-19 14:19:31 +00:00
}
2016-04-27 10:42:50 +00:00
# wsrep_cluster_address doesn't include garbd nodes
if ( $ nbNodes > $ nbNodesSize ) {
2016-04-19 14:19:31 +00:00
badprint
2016-04-27 10:42:50 +00:00
"All cluster nodes are not detected. wsrep_cluster_size less then node count in wsrep_cluster_address" ;
2016-04-19 14:19:31 +00:00
}
else {
2016-04-27 10:42:50 +00:00
goodprint "All cluster nodes detected." ;
2016-04-19 14:19:31 +00:00
}
}
else {
2016-04-06 08:33:56 +00:00
badprint "Galera Cluster address is undefined" ;
2016-04-19 14:19:31 +00:00
push @ adjvars ,
"set up wsrep_cluster_address variable for Galera replication" ;
}
if ( defined ( $ myvar { 'wsrep_cluster_name' } )
and trim ( $ myvar { 'wsrep_cluster_name' } ) ne "" )
{
goodprint "Galera Cluster name is defined: "
. $ myvar { 'wsrep_cluster_name' } ;
}
else {
badprint "Galera Cluster name is undefined" ;
push @ adjvars ,
"set up wsrep_cluster_name variable for Galera replication" ;
2016-04-06 08:33:56 +00:00
}
2016-04-19 14:19:31 +00:00
if ( defined ( $ myvar { 'wsrep_node_name' } )
and trim ( $ myvar { 'wsrep_node_name' } ) ne "" )
{
goodprint "Galera Node name is defined: "
. $ myvar { 'wsrep_node_name' } ;
2016-04-06 08:33:56 +00:00
}
2016-04-19 14:19:31 +00:00
else {
2016-04-15 14:17:56 +00:00
badprint "Galera node name is undefined" ;
2016-04-19 14:19:31 +00:00
push @ adjvars ,
"set up wsrep_node_name variable for Galera replication" ;
2016-04-15 14:17:56 +00:00
}
2016-04-19 14:19:31 +00:00
if ( trim ( $ myvar { 'wsrep_notify_cmd' } ) ne "" ) {
goodprint "Galera Notify command is defined." ;
2016-04-15 14:17:56 +00:00
}
2016-04-19 14:19:31 +00:00
else {
badprint "Galera Notify command is not defined." ;
push ( @ adjvars , "set up parameter wsrep_notify_cmd to be notify" ) ;
}
2016-04-21 07:08:20 +00:00
if ( trim ( $ myvar { 'wsrep_sst_method' } ) !~ "^xtrabackup.*" ) {
2016-04-21 07:06:13 +00:00
badprint "Galera SST method is not xtrabackup based." ;
push ( @ adjvars , "set up parameter wsrep_sst_method to xtrabackup based parameter" ) ;
2016-04-19 14:19:31 +00:00
}
else {
2016-04-21 21:19:36 +00:00
goodprint "SST Method is based on xtrabackup." ;
2016-04-15 14:17:56 +00:00
}
2016-07-04 06:41:16 +00:00
if ( ( defined ( $ myvar { 'wsrep_OSU_method' } ) && trim ( $ myvar { 'wsrep_OSU_method' } ) eq "TOI" ) ||
( defined ( $ myvar { 'wsrep_osu_method' } ) && trim ( $ myvar { 'wsrep_osu_method' } ) eq "TOI" ) ) {
2016-04-15 14:17:56 +00:00
goodprint "TOI is default mode for upgrade." ;
2016-04-19 14:19:31 +00:00
}
else {
2016-04-15 14:17:56 +00:00
badprint "Schema upgrade are not replicated automatically" ;
2016-04-19 14:19:31 +00:00
push ( @ adjvars , "set up parameter wsrep_OSU_method to TOI" ) ;
}
infoprint "Max WsRep message : "
. hr_bytes ( $ myvar { 'wsrep_max_ws_size' } ) ;
}
else {
badprint "Galera WsREP is disabled" ;
}
if ( defined ( $ mystat { 'wsrep_connected' } )
and $ mystat { 'wsrep_connected' } eq "ON" )
{
goodprint "Node is connected" ;
}
else {
badprint "Node is disconnected" ;
}
if ( defined ( $ mystat { 'wsrep_ready' } ) and $ mystat { 'wsrep_ready' } eq "ON" )
{
2016-04-15 14:17:56 +00:00
goodprint "Node is ready" ;
2016-04-19 14:19:31 +00:00
}
else {
2016-04-15 14:17:56 +00:00
badprint "Node is not ready" ;
2016-04-19 14:19:31 +00:00
}
infoprint "Cluster status :" . $ mystat { 'wsrep_cluster_status' } ;
if ( defined ( $ mystat { 'wsrep_cluster_status' } )
and $ mystat { 'wsrep_cluster_status' } eq "Primary" )
{
2016-04-15 14:17:56 +00:00
goodprint "Galera cluster is consistent and ready for operations" ;
2016-04-19 14:19:31 +00:00
}
else {
2016-04-15 14:17:56 +00:00
badprint "Cluster is not consistent and ready" ;
2016-04-19 14:19:31 +00:00
}
if ( $ mystat { 'wsrep_local_state_uuid' } eq
$ mystat { 'wsrep_cluster_state_uuid' } )
{
goodprint "Node and whole cluster at the same level: "
. $ mystat { 'wsrep_cluster_state_uuid' } ;
}
else {
badprint "Node and whole cluster not the same level" ;
infoprint "Node state uuid: " . $ mystat { 'wsrep_local_state_uuid' } ;
infoprint "Cluster state uuid: " . $ mystat { 'wsrep_cluster_state_uuid' } ;
}
if ( $ mystat { 'wsrep_local_state_comment' } eq 'Synced' ) {
2016-04-15 14:17:56 +00:00
goodprint "Node is synced with whole cluster." ;
2016-04-19 14:19:31 +00:00
}
else {
2016-04-15 14:17:56 +00:00
badprint "Node is not synced" ;
2016-04-19 14:19:31 +00:00
infoprint "Node State : " . $ mystat { 'wsrep_local_state_comment' } ;
}
if ( $ mystat { 'wsrep_local_cert_failures' } == 0 ) {
2016-04-15 14:17:56 +00:00
goodprint "There is no certification failures detected." ;
2016-04-19 14:19:31 +00:00
}
else {
badprint "There is "
. $ mystat { 'wsrep_local_cert_failures' }
. " certification failure(s)detected." ;
}
2016-04-15 14:17:56 +00:00
2016-04-19 14:19:31 +00:00
for my $ key ( keys % mystat ) {
if ( $ key =~ /wsrep_|galera/i ) {
debugprint "WSREP: $key = $mystat{$key}" ;
}
}
debugprint Dumper get_wsrep_options ( ) ;
2016-01-27 13:50:29 +00:00
}
2015-12-10 10:52:39 +00:00
# Recommendations for InnoDB
2015-06-18 08:56:47 +00:00
sub mysql_innodb {
2016-04-11 10:01:01 +00:00
subheaderprint "InnoDB Metrics" ;
2015-08-19 12:45:24 +00:00
# InnoDB
unless ( defined $ myvar { 'have_innodb' }
&& $ myvar { 'have_innodb' } eq "YES"
&& defined $ enginestats { 'InnoDB' } )
{
infoprint "InnoDB is disabled." ;
if ( mysql_version_ge ( 5 , 5 ) ) {
badprint
"InnoDB Storage engine is disabled. InnoDB is the default storage engine" ;
}
return ;
}
infoprint "InnoDB is enabled." ;
if ( $ opt { buffers } ne 0 ) {
infoprint "InnoDB Buffers" ;
if ( defined $ myvar { 'innodb_buffer_pool_size' } ) {
infoprint " +-- InnoDB Buffer Pool: "
. hr_bytes ( $ myvar { 'innodb_buffer_pool_size' } ) . "" ;
}
if ( defined $ myvar { 'innodb_buffer_pool_instances' } ) {
infoprint " +-- InnoDB Buffer Pool Instances: "
. $ myvar { 'innodb_buffer_pool_instances' } . "" ;
}
2016-08-30 12:38:16 +00:00
if ( defined $ myvar { 'innodb_buffer_pool_chunk_size' } ) {
infoprint " +-- InnoDB Buffer Pool Chunk Size: "
. hr_bytes ( $ myvar { 'innodb_buffer_pool_chunk_size' } ) . "" ;
}
2015-08-19 12:45:24 +00:00
if ( defined $ myvar { 'innodb_additional_mem_pool_size' } ) {
infoprint " +-- InnoDB Additional Mem Pool: "
. hr_bytes ( $ myvar { 'innodb_additional_mem_pool_size' } ) . "" ;
}
if ( defined $ myvar { 'innodb_log_buffer_size' } ) {
infoprint " +-- InnoDB Log Buffer: "
. hr_bytes ( $ myvar { 'innodb_log_buffer_size' } ) . "" ;
}
if ( defined $ mystat { 'Innodb_buffer_pool_pages_free' } ) {
infoprint " +-- InnoDB Log Buffer Free: "
. hr_bytes ( $ mystat { 'Innodb_buffer_pool_pages_free' } ) . "" ;
}
if ( defined $ mystat { 'Innodb_buffer_pool_pages_total' } ) {
infoprint " +-- InnoDB Log Buffer Used: "
. hr_bytes ( $ mystat { 'Innodb_buffer_pool_pages_total' } ) . "" ;
}
}
# InnoDB Buffer Pull Size
if ( $ myvar { 'innodb_buffer_pool_size' } > $ enginestats { 'InnoDB' } ) {
goodprint "InnoDB buffer pool / data size: "
. hr_bytes ( $ myvar { 'innodb_buffer_pool_size' } ) . "/"
. hr_bytes ( $ enginestats { 'InnoDB' } ) . "" ;
}
else {
2015-09-16 16:09:10 +00:00
badprint "InnoDB buffer pool / data size: "
2015-08-19 12:45:24 +00:00
. hr_bytes ( $ myvar { 'innodb_buffer_pool_size' } ) . "/"
. hr_bytes ( $ enginestats { 'InnoDB' } ) . "" ;
push ( @ adjvars ,
"innodb_buffer_pool_size (>= "
. hr_bytes_rnd ( $ enginestats { 'InnoDB' } )
. ") if possible." ) ;
}
# InnoDB Buffer Pull Instances (MySQL 5.6.6+)
if ( defined ( $ myvar { 'innodb_buffer_pool_instances' } ) ) {
# Bad Value if > 64
if ( $ myvar { 'innodb_buffer_pool_instances' } > 64 ) {
badprint "InnoDB buffer pool instances: "
. $ myvar { 'innodb_buffer_pool_instances' } . "" ;
push ( @ adjvars , "innodb_buffer_pool_instances (<= 64)" ) ;
}
# InnoDB Buffer Pull Size > 1Go
if ( $ myvar { 'innodb_buffer_pool_size' } > 1024 * 1024 * 1024 ) {
# InnoDB Buffer Pull Size / 1Go = InnoDB Buffer Pull Instances limited to 64 max.
# InnoDB Buffer Pull Size > 64Go
my $ max_innodb_buffer_pool_instances =
int ( $ myvar { 'innodb_buffer_pool_size' } / ( 1024 * 1024 * 1024 ) ) ;
$ max_innodb_buffer_pool_instances = 64
if ( $ max_innodb_buffer_pool_instances > 64 ) ;
if ( $ myvar { 'innodb_buffer_pool_instances' } !=
$ max_innodb_buffer_pool_instances )
{
badprint "InnoDB buffer pool instances: "
. $ myvar { 'innodb_buffer_pool_instances' } . "" ;
push ( @ adjvars ,
"innodb_buffer_pool_instances(="
. $ max_innodb_buffer_pool_instances
. ")" ) ;
}
else {
goodprint "InnoDB buffer pool instances: "
. $ myvar { 'innodb_buffer_pool_instances' } . "" ;
}
# InnoDB Buffer Pull Size < 1Go
}
else {
if ( $ myvar { 'innodb_buffer_pool_instances' } != 1 ) {
badprint
"InnoDB buffer pool <= 1G and innodb_buffer_pool_instances(!=1)." ;
push ( @ adjvars , "innodb_buffer_pool_instances (=1)" ) ;
}
else {
goodprint "InnoDB buffer pool instances: "
. $ myvar { 'innodb_buffer_pool_instances' } . "" ;
}
}
}
2016-08-30 12:38:16 +00:00
# InnoDB Used Buffer Pool Size vs CHUNK size
if ( ! defined ( $ myvar { 'innodb_buffer_pool_chunk_size' } ) ) {
infoprint "InnoDB Buffer Pool Chunk Size not used or defined in your version" ;
} else {
infoprint "Number of InnoDB Buffer Pool Chunk : " . int ( $ myvar { 'innodb_buffer_pool_size' } ) / int ( $ myvar { 'innodb_buffer_pool_chunk_size' } ) .
" for " . $ myvar { 'innodb_buffer_pool_instances' } . " Buffer Pool Instance(s)" ;
2015-08-19 12:45:24 +00:00
2016-08-30 15:03:21 +00:00
if ( int ( $ myvar { 'innodb_buffer_pool_size' } ) % ( int ( $ myvar { 'innodb_buffer_pool_chunk_size' } ) * int ( $ myvar { 'innodb_buffer_pool_instances' } ) ) ne 0 ) {
goodprint "innodb_buffer_pool_size is aligned with value innodb_buffer_pool_chunk_size and innodb_buffer_pool_instances" ;
} else {
badprint "innodb_buffer_pool_size is not aligned with value innodb_buffer_pool_chunk_size and innodb_buffer_pool_instances" ;
#push( @adjvars, "Adjust innodb_buffer_pool_instances, innodb_buffer_pool_chunk_size with innodb_buffer_pool_size" );
push ( @ adjvars , "innodb_buffer_pool_size must always be equal to or a multiple of innodb_buffer_pool_chunk_size * innodb_buffer_pool_instances" ) ;
}
}
2015-08-19 12:45:24 +00:00
# InnoDB Read efficency
if ( defined $ mycalc { 'pct_read_efficiency' }
&& $ mycalc { 'pct_read_efficiency' } < 90 )
{
badprint "InnoDB Read buffer efficiency: "
. $ mycalc { 'pct_read_efficiency' } . "% ("
. ( $ mystat { 'Innodb_buffer_pool_read_requests' } -
$ mystat { 'Innodb_buffer_pool_reads' } )
. " hits/ "
. $ mystat { 'Innodb_buffer_pool_read_requests' }
. " total)" ;
}
else {
goodprint "InnoDB Read buffer efficiency: "
. $ mycalc { 'pct_read_efficiency' } . "% ("
. ( $ mystat { 'Innodb_buffer_pool_read_requests' } -
$ mystat { 'Innodb_buffer_pool_reads' } )
. " hits/ "
. $ mystat { 'Innodb_buffer_pool_read_requests' }
. " total)" ;
}
# InnoDB Write efficiency
if ( defined $ mycalc { 'pct_write_efficiency' }
&& $ mycalc { 'pct_write_efficiency' } < 90 )
{
2016-02-24 19:20:48 +00:00
badprint "InnoDB Write Log efficiency: "
2016-04-19 14:19:31 +00:00
. abs ( $ mycalc { 'pct_write_efficiency' } ) . "% ("
2016-04-14 21:11:18 +00:00
. abs ( $ mystat { 'Innodb_log_write_requests' } -
2016-02-24 19:20:48 +00:00
$ mystat { 'Innodb_log_writes' } )
2015-08-19 12:45:24 +00:00
. " hits/ "
2016-02-24 19:20:48 +00:00
. $ mystat { 'Innodb_log_write_requests' }
2015-08-19 12:45:24 +00:00
. " total)" ;
}
else {
2016-02-24 19:20:48 +00:00
goodprint "InnoDB Write log efficiency: "
2015-08-19 12:45:24 +00:00
. $ mycalc { 'pct_write_efficiency' } . "% ("
2016-02-24 19:20:48 +00:00
. ( $ mystat { 'Innodb_log_write_requests' } -
$ mystat { 'Innodb_log_writes' } )
2015-08-19 12:45:24 +00:00
. " hits/ "
2016-02-24 19:20:48 +00:00
. $ mystat { 'Innodb_log_write_requests' }
2015-08-19 12:45:24 +00:00
. " total)" ;
}
# InnoDB Log Waits
if ( defined $ mystat { 'Innodb_log_waits' }
&& $ mystat { 'Innodb_log_waits' } > 0 )
{
badprint "InnoDB log waits: "
. percentage ( $ mystat { 'Innodb_log_waits' } ,
$ mystat { 'Innodb_log_writes' } )
. "% ("
. $ mystat { 'Innodb_log_waits' }
. " waits / "
. $ mystat { 'Innodb_log_writes' }
. " writes)" ;
push ( @ adjvars ,
"innodb_log_buffer_size (>= "
. hr_bytes_rnd ( $ myvar { 'innodb_log_buffer_size' } )
. ")" ) ;
}
else {
goodprint "InnoDB log waits: "
. percentage ( $ mystat { 'Innodb_log_waits' } ,
$ mystat { 'Innodb_log_writes' } )
. "% ("
. $ mystat { 'Innodb_log_waits' }
. " waits / "
. $ mystat { 'Innodb_log_writes' }
. " writes)" ;
}
$ result { 'Calculations' } = { % mycalc } ;
2015-06-18 08:56:47 +00:00
}
2015-06-18 20:02:55 +00:00
2015-12-10 10:52:39 +00:00
# Recommendations for Database metrics
2015-06-18 20:02:55 +00:00
sub mysql_databases {
2015-08-19 12:45:24 +00:00
return if ( $ opt { dbstat } == 0 ) ;
2016-04-11 10:01:01 +00:00
subheaderprint "Database Metrics" ;
2015-08-19 12:45:24 +00:00
unless ( mysql_version_ge ( 5 , 5 ) ) {
infoprint
"Skip Database metrics from information schema missing in this version" ;
return ;
}
my @ dblist = select_array ( "SHOW DATABASES;" ) ;
infoprint "There is " . scalar ( @ dblist ) . " Database(s)." ;
my @ totaldbinfo = split /\s/ ,
select_one (
2016-04-15 10:33:05 +00:00
"SELECT SUM(TABLE_ROWS), SUM(DATA_LENGTH), SUM(INDEX_LENGTH) , SUM(DATA_LENGTH+INDEX_LENGTH), COUNT(TABLE_NAME),COUNT(DISTINCT(TABLE_COLLATION)),COUNT(DISTINCT(ENGINE)) FROM information_schema.TABLES WHERE TABLE_SCHEMA NOT IN ( 'mysql' );"
2015-08-19 12:45:24 +00:00
) ;
infoprint "All Databases:" ;
2016-03-22 15:36:04 +00:00
infoprint " +-- TABLE : "
. ( $ totaldbinfo [ 4 ] eq 'NULL' ? 0 : $ totaldbinfo [ 4 ] ) . "" ;
infoprint " +-- ROWS : "
2015-08-19 12:45:24 +00:00
. ( $ totaldbinfo [ 0 ] eq 'NULL' ? 0 : $ totaldbinfo [ 0 ] ) . "" ;
2016-03-22 15:36:04 +00:00
infoprint " +-- DATA : "
2015-08-19 12:45:24 +00:00
. hr_bytes ( $ totaldbinfo [ 1 ] ) . "("
. percentage ( $ totaldbinfo [ 1 ] , $ totaldbinfo [ 3 ] ) . "%)" ;
2016-03-22 15:36:04 +00:00
infoprint " +-- INDEX : "
2015-08-19 12:45:24 +00:00
. hr_bytes ( $ totaldbinfo [ 2 ] ) . "("
. percentage ( $ totaldbinfo [ 2 ] , $ totaldbinfo [ 3 ] ) . "%)" ;
2016-03-22 15:36:04 +00:00
infoprint " +-- SIZE : " . hr_bytes ( $ totaldbinfo [ 3 ] ) . "" ;
infoprint " +-- COLLA : "
2016-03-29 12:22:45 +00:00
. ( $ totaldbinfo [ 5 ] eq 'NULL' ? 0 : $ totaldbinfo [ 5 ] ) . " ("
. (
join ", " ,
select_array (
"SELECT DISTINCT(TABLE_COLLATION) FROM information_schema.TABLES;" )
) . ")" ;
2016-03-22 16:56:08 +00:00
infoprint " +-- ENGIN : "
2016-03-29 12:22:45 +00:00
. ( $ totaldbinfo [ 6 ] eq 'NULL' ? 0 : $ totaldbinfo [ 6 ] ) . " ("
. (
join ", " ,
select_array ( "SELECT DISTINCT(ENGINE) FROM information_schema.TABLES;" )
) . ")" ;
2015-08-19 12:45:24 +00:00
$ result { 'Databases' } { 'All databases' } { 'Rows' } =
( $ totaldbinfo [ 0 ] eq 'NULL' ? 0 : $ totaldbinfo [ 0 ] ) ;
$ result { 'Databases' } { 'All databases' } { 'Data Size' } = $ totaldbinfo [ 1 ] ;
$ result { 'Databases' } { 'All databases' } { 'Data Pct' } =
percentage ( $ totaldbinfo [ 1 ] , $ totaldbinfo [ 3 ] ) . "%" ;
$ result { 'Databases' } { 'All databases' } { 'Index Size' } = $ totaldbinfo [ 2 ] ;
$ result { 'Databases' } { 'All databases' } { 'Index Pct' } =
percentage ( $ totaldbinfo [ 2 ] , $ totaldbinfo [ 3 ] ) . "%" ;
2016-03-29 12:22:45 +00:00
$ result { 'Databases' } { 'All databases' } { 'Total Size' } = $ totaldbinfo [ 3 ] ;
print "\n" unless ( $ opt { 'silent' } or $ opt { 'json' } ) ;
2015-08-19 12:45:24 +00:00
foreach ( @ dblist ) {
chomp ( $ _ ) ;
2016-04-19 14:19:31 +00:00
if ( $ _ eq "information_schema"
2015-08-19 12:45:24 +00:00
or $ _ eq "performance_schema"
2016-04-15 10:33:05 +00:00
or $ _ eq "mysql"
2016-04-19 14:19:31 +00:00
or $ _ eq "" )
2015-08-19 12:45:24 +00:00
{
next ;
}
my @ dbinfo = split /\s/ ,
select_one (
2016-03-22 16:56:08 +00:00
"SELECT TABLE_SCHEMA, SUM(TABLE_ROWS), SUM(DATA_LENGTH), SUM(INDEX_LENGTH) , SUM(DATA_LENGTH+INDEX_LENGTH), COUNT(DISTINCT ENGINE),COUNT(TABLE_NAME),COUNT(DISTINCT(TABLE_COLLATION)),COUNT(DISTINCT(ENGINE)) FROM information_schema.TABLES WHERE TABLE_SCHEMA='$_' GROUP BY TABLE_SCHEMA ORDER BY TABLE_SCHEMA"
2015-08-19 12:45:24 +00:00
) ;
next unless defined $ dbinfo [ 0 ] ;
infoprint "Database: " . $ dbinfo [ 0 ] . "" ;
2016-03-22 15:36:04 +00:00
infoprint " +-- TABLE: "
. ( ! defined ( $ dbinfo [ 6 ] ) or $ dbinfo [ 6 ] eq 'NULL' ? 0 : $ dbinfo [ 6 ] )
. "" ;
infoprint " +-- COLL : "
2016-03-29 12:22:45 +00:00
. ( $ dbinfo [ 7 ] eq 'NULL' ? 0 : $ dbinfo [ 7 ] ) . " ("
. (
join ", " ,
select_array (
"SELECT DISTINCT(TABLE_COLLATION) FROM information_schema.TABLES WHERE TABLE_SCHEMA='$_';"
)
) . ")" ;
2015-08-19 12:45:24 +00:00
infoprint " +-- ROWS : "
. ( ! defined ( $ dbinfo [ 1 ] ) or $ dbinfo [ 1 ] eq 'NULL' ? 0 : $ dbinfo [ 1 ] )
. "" ;
infoprint " +-- DATA : "
. hr_bytes ( $ dbinfo [ 2 ] ) . "("
. percentage ( $ dbinfo [ 2 ] , $ dbinfo [ 4 ] ) . "%)" ;
infoprint " +-- INDEX: "
. hr_bytes ( $ dbinfo [ 3 ] ) . "("
. percentage ( $ dbinfo [ 3 ] , $ dbinfo [ 4 ] ) . "%)" ;
infoprint " +-- TOTAL: " . hr_bytes ( $ dbinfo [ 4 ] ) . "" ;
2016-03-22 16:56:08 +00:00
infoprint " +-- ENGIN : "
2016-03-29 12:22:45 +00:00
. ( $ dbinfo [ 8 ] eq 'NULL' ? 0 : $ dbinfo [ 8 ] ) . " ("
. (
join ", " ,
select_array (
"SELECT DISTINCT(ENGINE) FROM information_schema.TABLES WHERE TABLE_SCHEMA='$_'"
)
) . ")" ;
2015-08-19 12:45:24 +00:00
badprint "Index size is larger than data size for $dbinfo[0] \n"
if $ dbinfo [ 2 ] < $ dbinfo [ 3 ] ;
2015-12-10 10:52:39 +00:00
badprint "There are " . $ dbinfo [ 5 ] . " storage engines. Be careful. \n"
2015-08-19 12:45:24 +00:00
if $ dbinfo [ 5 ] > 1 ;
2016-03-29 12:22:45 +00:00
$ result { 'Databases' } { $ dbinfo [ 0 ] } { 'Rows' } = $ dbinfo [ 1 ] ;
$ result { 'Databases' } { $ dbinfo [ 0 ] } { 'Tables' } = $ dbinfo [ 6 ] ;
$ result { 'Databases' } { $ dbinfo [ 0 ] } { 'Collations' } = $ dbinfo [ 7 ] ;
$ result { 'Databases' } { $ dbinfo [ 0 ] } { 'Data Size' } = $ dbinfo [ 2 ] ;
2015-08-19 12:45:24 +00:00
$ result { 'Databases' } { $ dbinfo [ 0 ] } { 'Data Pct' } =
percentage ( $ dbinfo [ 2 ] , $ dbinfo [ 4 ] ) . "%" ;
$ result { 'Databases' } { $ dbinfo [ 0 ] } { 'Index Size' } = $ dbinfo [ 3 ] ;
$ result { 'Databases' } { $ dbinfo [ 0 ] } { 'Index Pct' } =
percentage ( $ dbinfo [ 3 ] , $ dbinfo [ 4 ] ) . "%" ;
$ result { 'Databases' } { $ dbinfo [ 0 ] } { 'Total Size' } = $ dbinfo [ 4 ] ;
2016-03-22 16:56:08 +00:00
2016-03-29 12:22:45 +00:00
if ( $ dbinfo [ 7 ] > 1 ) {
badprint $ dbinfo [ 7 ]
2016-04-22 15:22:00 +00:00
. " different collations for database "
2016-03-29 12:22:45 +00:00
. $ dbinfo [ 0 ] ;
push ( @ generalrec ,
"Check all table collations are identical for all tables in "
. $ dbinfo [ 0 ]
. " database." ) ;
}
else {
goodprint $ dbinfo [ 7 ]
. " collation for "
. $ dbinfo [ 0 ]
. " database." ;
}
if ( $ dbinfo [ 8 ] > 1 ) {
badprint $ dbinfo [ 8 ]
2016-04-22 15:22:00 +00:00
. " different engines for database "
2016-03-29 12:22:45 +00:00
. $ dbinfo [ 0 ] ;
push ( @ generalrec ,
"Check all table engines are identical for all tables in "
. $ dbinfo [ 0 ]
. " database." ) ;
}
else {
goodprint $ dbinfo [ 8 ] . " engine for " . $ dbinfo [ 0 ] . " database." ;
}
my @ distinct_column_charset = select_array (
"select DISTINCT(CHARACTER_SET_NAME) from information_schema.COLUMNS where CHARACTER_SET_NAME IS NOT NULL AND TABLE_SCHEMA ='$_'"
) ;
infoprint "Charsets for $dbinfo[0] database table column: "
. join ( ', ' , @ distinct_column_charset ) ;
if ( scalar ( @ distinct_column_charset ) > 1 ) {
badprint $ dbinfo [ 0 ]
. " table column(s) has several charsets defined for all text like column(s)." ;
push ( @ generalrec ,
"Limit charset for column to one charset if possible for "
. $ dbinfo [ 0 ]
. " database." ) ;
}
else {
goodprint $ dbinfo [ 0 ]
. " table column(s) has same charset defined for all text like column(s)." ;
}
my @ distinct_column_collation = select_array (
"select DISTINCT(COLLATION_NAME) from information_schema.COLUMNS where COLLATION_NAME IS NOT NULL AND TABLE_SCHEMA ='$_'"
) ;
infoprint "Collations for $dbinfo[0] database table column: "
. join ( ', ' , @ distinct_column_collation ) ;
if ( scalar ( @ distinct_column_collation ) > 1 ) {
badprint $ dbinfo [ 0 ]
. " table column(s) has several collations defined for all text like column(s)." ;
push ( @ generalrec ,
"Limit collations for column to one collation if possible for "
. $ dbinfo [ 0 ]
. " database." ) ;
}
else {
goodprint $ dbinfo [ 0 ]
. " table column(s) has same collation defined for all text like column(s)." ;
}
2016-03-22 16:56:08 +00:00
}
2016-03-29 12:22:45 +00:00
2015-06-18 20:02:55 +00:00
}
2015-12-10 10:52:39 +00:00
# Recommendations for Indexes metrics
2015-07-01 22:19:28 +00:00
sub mysql_indexes {
2015-08-19 12:45:24 +00:00
return if ( $ opt { idxstat } == 0 ) ;
2016-04-11 10:01:01 +00:00
subheaderprint "Indexes Metrics" ;
2015-08-19 12:45:24 +00:00
unless ( mysql_version_ge ( 5 , 5 ) ) {
infoprint
2016-03-29 12:22:45 +00:00
"Skip Index metrics from information schema missing in this version" ;
2015-08-19 12:45:24 +00:00
return ;
}
2016-03-29 12:22:45 +00:00
2016-03-14 11:10:35 +00:00
# unless ( mysql_version_ge( 5, 6 ) ) {
# infoprint
2016-04-22 15:22:00 +00:00
#"Skip Index metrics from information schema due to erroneous information provided in this version";
2016-03-14 11:10:35 +00:00
# return;
# }
2015-08-19 12:45:24 +00:00
my $ selIdxReq = << 'ENDSQL' ;
2015-07-02 10:16:02 +00:00
SELECT
CONCAT ( CONCAT ( t . TABLE_SCHEMA , '.' ) , t . TABLE_NAME ) AS 'table'
, CONCAT ( CONCAT ( CONCAT ( s . INDEX_NAME , '(' ) , s . COLUMN_NAME ) , ')' ) AS 'index'
, s . SEQ_IN_INDEX AS 'seq'
, s2 . max_columns AS 'maxcol'
, s . CARDINALITY AS 'card'
, t . TABLE_ROWS AS 'est_rows'
2016-03-14 11:10:35 +00:00
, INDEX_TYPE as type
2015-07-02 10:16:02 +00:00
, ROUND ( ( ( s . CARDINALITY / IFNULL ( t . TABLE_ROWS , 0.01 ) ) * 100 ) , 2 ) AS 'sel'
FROM INFORMATION_SCHEMA . STATISTICS s
INNER JOIN INFORMATION_SCHEMA . TABLES t
ON s . TABLE_SCHEMA = t . TABLE_SCHEMA
AND s . TABLE_NAME = t . TABLE_NAME
INNER JOIN (
2015-11-23 07:08:25 +00:00
SELECT
2015-07-02 10:16:02 +00:00
TABLE_SCHEMA
, TABLE_NAME
, INDEX_NAME
, MAX ( SEQ_IN_INDEX ) AS max_columns
FROM INFORMATION_SCHEMA . STATISTICS
WHERE TABLE_SCHEMA NOT IN ( 'mysql' , 'information_schema' , 'performance_schema' )
2016-03-22 08:54:26 +00:00
AND INDEX_TYPE < > 'FULLTEXT'
2015-07-02 10:16:02 +00:00
GROUP BY TABLE_SCHEMA , TABLE_NAME , INDEX_NAME
) AS s2
ON s . TABLE_SCHEMA = s2 . TABLE_SCHEMA
AND s . TABLE_NAME = s2 . TABLE_NAME
AND s . INDEX_NAME = s2 . INDEX_NAME
WHERE t . TABLE_SCHEMA NOT IN ( 'mysql' , 'information_schema' , 'performance_schema' )
AND t . TABLE_ROWS > 10
AND s . CARDINALITY IS NOT NULL
AND ( s . CARDINALITY / IFNULL ( t . TABLE_ROWS , 0.01 ) ) < 8.00
ORDER BY sel
LIMIT 10 ;
ENDSQL
2015-08-19 12:45:24 +00:00
my @ idxinfo = select_array ( $ selIdxReq ) ;
infoprint "Worst selectivity indexes:" ;
foreach ( @ idxinfo ) {
debugprint "$_" ;
my @ info = split /\s/ ;
infoprint "Index: " . $ info [ 1 ] . "" ;
infoprint " +-- COLUNM : " . $ info [ 0 ] . "" ;
infoprint " +-- NB SEQS : " . $ info [ 2 ] . " sequence(s)" ;
infoprint " +-- NB COLS : " . $ info [ 3 ] . " column(s)" ;
infoprint " +-- CARDINALITY : " . $ info [ 4 ] . " distinct values" ;
infoprint " +-- NB ROWS : " . $ info [ 5 ] . " rows" ;
2016-03-29 12:22:45 +00:00
infoprint " +-- TYPE : " . $ info [ 6 ] ;
2016-03-22 08:54:26 +00:00
infoprint " +-- SELECTIVITY : " . $ info [ 7 ] . "%" ;
2015-08-19 12:45:24 +00:00
$ result { 'Indexes' } { $ info [ 1 ] } { 'Colunm' } = $ info [ 0 ] ;
$ result { 'Indexes' } { $ info [ 1 ] } { 'Sequence number' } = $ info [ 2 ] ;
$ result { 'Indexes' } { $ info [ 1 ] } { 'Number of collunm' } = $ info [ 3 ] ;
$ result { 'Indexes' } { $ info [ 1 ] } { 'Cardianality' } = $ info [ 4 ] ;
$ result { 'Indexes' } { $ info [ 1 ] } { 'Row number' } = $ info [ 5 ] ;
2016-03-22 08:54:26 +00:00
$ result { 'Indexes' } { $ info [ 1 ] } { 'Index Type' } = $ info [ 6 ] ;
$ result { 'Indexes' } { $ info [ 1 ] } { 'Selectivity' } = $ info [ 7 ] ;
if ( $ info [ 7 ] < 25 ) {
2015-08-19 12:45:24 +00:00
badprint "$info[1] has a low selectivity" ;
}
2016-03-29 12:22:45 +00:00
}
2015-08-19 12:45:24 +00:00
return
unless ( defined ( $ myvar { 'performance_schema' } )
and $ myvar { 'performance_schema' } eq 'ON' ) ;
$ selIdxReq = << 'ENDSQL' ;
2015-11-23 07:08:25 +00:00
SELECT CONCAT ( CONCAT ( object_schema , '.' ) , object_name ) AS 'table' , index_name
2015-07-02 14:42:53 +00:00
FROM performance_schema . table_io_waits_summary_by_index_usage
WHERE index_name IS NOT NULL
2015-11-23 07:08:25 +00:00
AND count_star = 0
AND index_name < > 'PRIMARY'
AND object_schema != 'mysql'
2015-07-02 14:42:53 +00:00
ORDER BY count_star , object_schema , object_name ;
ENDSQL
2015-08-19 12:45:24 +00:00
@ idxinfo = select_array ( $ selIdxReq ) ;
2015-12-10 10:52:39 +00:00
infoprint "Unused indexes:" ;
2015-08-19 12:45:24 +00:00
push ( @ generalrec , "Remove unused indexes." ) if ( scalar ( @ idxinfo ) > 0 ) ;
foreach ( @ idxinfo ) {
debugprint "$_" ;
my @ info = split /\s/ ;
badprint "Index: $info[1] on $info[0] is not used." ;
push @ { $ result { 'Indexes' } { 'Unused Indexes' } } ,
$ info [ 0 ] . "." . $ info [ 1 ] ;
}
2015-07-01 22:19:28 +00:00
}
2015-08-19 12:45:24 +00:00
2008-09-08 01:16:39 +00:00
# Take the two recommendation arrays and display them at the end of the output
sub make_recommendations {
2016-08-09 14:04:13 +00:00
$ result { 'Recommendations' } = \ @ generalrec ;
$ result { 'Adjust variables' } = \ @ adjvars ;
2016-04-11 10:01:01 +00:00
subheaderprint "Recommendations" ;
2015-08-19 12:45:24 +00:00
if ( @ generalrec > 0 ) {
prettyprint "General recommendations:" ;
foreach ( @ generalrec ) { prettyprint " " . $ _ . "" ; }
}
if ( @ adjvars > 0 ) {
prettyprint "Variables to adjust:" ;
if ( $ mycalc { 'pct_max_physical_memory' } > 90 ) {
prettyprint
" *** MySQL's maximum memory usage is dangerously high ***\n"
. " *** Add RAM before increasing MySQL buffer variables ***" ;
}
foreach ( @ adjvars ) { prettyprint " " . $ _ . "" ; }
}
if ( @ generalrec == 0 && @ adjvars == 0 ) {
2016-03-29 12:22:45 +00:00
prettyprint "No additional performance recommendations are available." ;
2015-08-19 12:45:24 +00:00
}
2008-09-08 01:16:39 +00:00
}
2015-08-19 12:45:24 +00:00
2015-08-26 13:23:19 +00:00
sub close_outputfile {
2015-08-19 12:45:24 +00:00
close ( $ fh ) if defined ( $ fh ) ;
2015-06-17 16:03:44 +00:00
}
2015-07-16 15:14:42 +00:00
sub headerprint {
2015-08-19 12:45:24 +00:00
prettyprint
" >> MySQLTuner $tunerversion - Major Hayden <major\@mhtx.net>\n"
. " >> Bug reports, feature requests, and downloads at http://mysqltuner.com/\n"
. " >> Run with '--help' for additional options and output filtering" ;
2015-07-16 15:14:42 +00:00
}
2015-08-26 13:23:19 +00:00
sub string2file {
2016-03-29 12:22:45 +00:00
my $ filename = shift ;
my $ content = shift ;
open my $ fh , q( > ) , $ filename
or die
"Unable to open $filename in write mode. Please check permissions for this file or directory" ;
print $ fh $ content if defined ( $ content ) ;
close $ fh ;
debugprint $ content if ( $ opt { 'debug' } ) ;
2015-08-26 13:23:19 +00:00
}
sub file2array {
my $ filename = shift ;
2016-03-29 12:22:45 +00:00
debugprint "* reading $filename" if ( $ opt { 'debug' } ) ;
2015-08-26 13:23:19 +00:00
my $ fh ;
open ( $ fh , q( < ) , "$filename" )
or die "Couldn't open $filename for reading: $!\n" ;
my @ lines = <$fh> ;
close ( $ fh ) ;
return @ lines ;
}
sub file2string {
2016-03-29 12:22:45 +00:00
return join ( '' , file2array ( @ _ ) ) ;
2015-08-26 13:23:19 +00:00
}
my $ templateModel ;
2016-03-29 12:22:45 +00:00
if ( $ opt { 'template' } ne 0 ) {
$ templateModel = file2string ( $ opt { 'template' } ) ;
}
else {
# DEFAULT REPORT TEMPLATE
$ templateModel = << 'END_TEMPLATE' ;
2015-08-26 13:23:19 +00:00
< ! DOCTYPE html >
<html>
<head>
2015-12-10 10:52:39 +00:00
<title> MySQLTuner Report </title>
2015-08-26 13:23:19 +00:00
< meta charset = "UTF-8" >
</head>
<body>
<h1> Result output </h1>
<pre>
{ $ data }
</pre>
</body>
</html>
END_TEMPLATE
}
2016-03-29 12:22:45 +00:00
2015-07-16 15:14:42 +00:00
sub dump_result {
2016-03-29 12:22:45 +00:00
if ( $ opt { 'debug' } ) {
debugprint Dumper ( \ % result ) ;
2015-08-26 13:23:19 +00:00
}
debugprint "HTML REPORT: $opt{'reportfile'}" ;
2015-11-23 07:14:28 +00:00
2016-03-29 12:22:45 +00:00
if ( $ opt { 'reportfile' } ne 0 ) {
2016-08-30 12:50:36 +00:00
eval { require Text::Template } ;
2016-03-29 12:22:45 +00:00
if ( $@ ) {
badprint "Text::Template Module is needed." ;
exit 1 ;
}
my $ vars = { 'data' = > Dumper ( \ % result ) } ;
my $ template ;
{
no warnings 'once' ;
$ template = Text::Template - > new (
TYPE = > 'STRING' ,
PREPEND = > q{ ; } ,
SOURCE = > $ templateModel
) or die "Couldn't construct template: $Text::Template::ERROR" ;
}
open my $ fh , q( > ) , $ opt { 'reportfile' }
or die
"Unable to open $opt{'reportfile'} in write mode. please check permissions for this file or directory" ;
$ template - > fill_in ( HASH = > $ vars , OUTPUT = > $ fh ) ;
close $ fh ;
}
if ( $ opt { 'json' } ne 0 ) {
2016-08-30 12:50:36 +00:00
eval { require JSON } ;
2016-03-29 12:22:45 +00:00
if ( $@ ) {
2016-06-03 09:03:52 +00:00
print "JSON Module is needed." ;
2016-03-29 12:22:45 +00:00
exit 1 ;
}
my $ json = JSON - > new - > allow_nonref ;
print $ json - > utf8 ( 1 ) - > pretty ( ( $ opt { 'prettyjson' } ? 1 : 0 ) )
- > encode ( \ % result ) ;
2016-01-27 13:50:29 +00:00
}
2015-07-16 15:14:42 +00:00
}
2015-08-19 12:45:24 +00:00
2016-04-18 14:45:34 +00:00
sub which {
2016-04-19 14:19:31 +00:00
my $ prog_name = shift ;
2016-04-18 14:45:34 +00:00
my $ path_string = shift ;
2016-04-19 14:19:31 +00:00
my @ path_array = split /:/ , $ ENV { 'PATH' } ;
2016-04-18 14:45:34 +00:00
2016-04-19 14:19:31 +00:00
for my $ path ( @ path_array ) {
2016-04-18 14:45:34 +00:00
if ( - x "$path/$prog_name" ) {
return "$path/$prog_name" ;
}
}
2016-04-19 14:19:31 +00:00
return 0 ;
2016-04-18 14:45:34 +00:00
}
2008-09-08 01:16:39 +00:00
# ---------------------------------------------------------------------------
# BEGIN 'MAIN'
# ---------------------------------------------------------------------------
2016-02-20 16:05:33 +00:00
headerprint ; # Header Print
2015-08-25 15:00:06 +00:00
validate_tuner_version ; # Check last version
2016-06-11 16:19:55 +00:00
mysql_setup ; # Gotta login first
2015-08-19 12:45:24 +00:00
os_setup ; # Set up some OS variables
get_all_vars ; # Toss variables/status into hashes
get_tuning_info ; # Get information about the tuning connexion
validate_mysql_version ; # Check current MySQL version
2016-08-26 08:40:58 +00:00
2015-08-19 12:45:24 +00:00
check_architecture ; # Suggest 64-bit upgrade
2016-03-24 22:58:48 +00:00
system_recommendations ; # avoid to many service on the same host
2015-08-19 12:45:24 +00:00
check_storage_engines ; # Show enabled storage engines
mysql_databases ; # Show informations about databases
mysql_indexes ; # Show informations about indexes
security_recommendations ; # Display some security recommendations
2016-01-05 23:57:34 +00:00
cve_recommendations ; # Display related CVE
2015-08-19 12:45:24 +00:00
calculations ; # Calculate everything we need
mysql_stats ; # Print the server stats
2016-06-11 16:19:55 +00:00
mysqsl_pfs ; # Print Performance schema info
2016-04-21 21:16:35 +00:00
mariadb_threadpool ; # Print MaraiDB ThreadPool stats
2016-03-16 17:40:44 +00:00
mysql_myisam ; # Print MyISAM stats
2016-01-27 13:50:29 +00:00
mariadb_ariadb ; # Print MaraiDB AriaDB stats
2016-03-16 17:40:44 +00:00
mysql_innodb ; # Print InnoDB stats
2016-01-27 13:50:29 +00:00
mariadb_tokudb ; # Print MaraiDB TokuDB stats
mariadb_galera ; # Print MaraiDB Galera Cluster stats
2015-08-19 12:45:24 +00:00
get_replication_status ; # Print replication info
make_recommendations ; # Make recommendations based on stats
dump_result ; # Dump result if debug is on
2015-08-26 13:23:19 +00:00
close_outputfile ; # Close reportfile if needed
2015-08-19 12:45:24 +00:00
2008-09-08 01:16:39 +00:00
# ---------------------------------------------------------------------------
# END 'MAIN'
# ---------------------------------------------------------------------------
2015-08-25 15:00:06 +00:00
1 ;
2015-08-26 13:23:19 +00:00
2015-07-01 10:31:40 +00:00
__END__
= pod
2015-07-01 11:33:57 +00:00
2015-07-01 10:31:40 +00:00
= encoding UTF - 8
= head1 NAME
2016-08-30 12:48:48 +00:00
MySQLTuner 1.6 .18 - MySQL High Performance Tuning Script
2015-07-01 10:31:40 +00:00
= head1 IMPORTANT USAGE GUIDELINES
To run the script with the default options , run the script without arguments
Allow MySQL server to run for at least 24 - 48 hours before trusting suggestions
Some routines may require root level privileges ( script will provide warnings )
You must provide the remote server ' s total memory when connecting to other servers
= head1 CONNECTION AND AUTHENTIFICATION
- - host <hostname> Connect to a remote host to perform tests ( default: localhost )
- - socket <socket> Use a different socket for a local connection
- - port <port> Port to use for connection ( default: 3306 )
- - user <username> Username to use for authentication
- - pass <password> Password to use for authentication
- - mysqladmin <path> Path to a custom mysqladmin executable
- - mysqlcmd <path> Path to a custom mysql executable
= head1 PERFORMANCE AND REPORTING OPTIONS
2016-03-24 22:58:48 +00:00
- - skipsize Don ' t enumerate tables and their types / sizes ( default: on )
( Recommended for servers with many tables )
- - skippassword Don ' t perform checks on user passwords ( default: off )
- - checkversion Check for updates to MySQLTuner ( default: don ' t check )
- - updateversion Check for updates to MySQLTuner and update when newer version is available ( default: don ' t check )
- - forcemem <size> Amount of RAM installed in megabytes
- - forceswap <size> Amount of swap memory configured in megabytes
- - passwordfile <path> Path to a password file list ( one password by line )
2015-11-23 07:08:25 +00:00
2015-07-01 10:31:40 +00:00
= head1 OUTPUT OPTIONS
2016-01-05 23:57:34 +00:00
2016-03-24 22:58:48 +00:00
- - silent Don ' t output anything on screen
- - nogood Remove OK responses
- - nobad Remove negative / suggestion responses
- - noinfo Remove informational responses
- - debug Print debug information
- - dbstat Print database information
- - idxstat Print index information
2016-03-30 15:16:16 +00:00
- - sysstat Print system information
2016-03-24 22:58:48 +00:00
- - bannedports Ports banned separated by comma ( , )
- - maxportallowed Number of ports opened allowed on this hosts
- - cvefile CVE File for vulnerability checks
- - nocolor Don ' t print output in color
- - json Print result as JSON string
- - buffers Print global and per - thread buffer values
- - outputfile <path> Path to a output txt file
- - reportfile <path> Path to a report txt file
- - template <path> Path to a template file
- - verbose Prints out all options ( default: no verbose )
2015-07-01 11:33:57 +00:00
= head1 PERLDOC
2015-07-01 10:31:40 +00:00
You can find documentation for this module with the perldoc command .
perldoc mysqltuner
2015-12-10 10:52:39 +00:00
= head2 INTERNALS
2015-08-19 16:25:25 +00:00
L <https://github.com/major/MySQLTuner-perl/blob/master/INTERNALS.md>
Internal documentation
2015-07-01 10:31:40 +00:00
= head1 AUTHORS
Major Hayden - major @ mhtx . net
= head1 CONTRIBUTORS
= over 4
= item *
Matthew Montgomery
= item *
Paul Kehrer
= item *
Dave Burgess
= item *
Jonathan Hinds
= item *
Mike Jackson
= item *
Nils Breunese
= item *
Shawn Ashlee
= item *
Luuk Vosslamber
= item *
Ville Skytta
= item *
Trent Hornibrook
= item *
Jason Gill
= item *
Mark Imbriaco
= item *
Greg Eden
= item *
Aubin Galinotti
= item *
Giovanni Bechis
= item *
Bill Bradford
= item *
Ryan Novosielski
= item *
Michael Scheidell
= item *
Blair Christensen
= item *
Hans du Plooy
= item *
Victor Trac
= item *
Everett Barnes
= item *
Tom Krouper
= item *
Gary Barrueto
= item *
Simon Greenaway
= item *
Adam Stein
= item *
Isart Montane
= item *
Baptiste M .
= item *
Cole Turner
= item *
Major Hayden
2015-07-15 09:09:51 +00:00
= item *
Joe Ashcraft
2015-07-16 15:14:42 +00:00
= item *
Jean - Marie Renouard
2015-12-10 10:52:39 +00:00
= item *
2016-01-05 23:57:34 +00:00
Stephan GroBberndt
2015-12-10 10:52:39 +00:00
2016-08-30 11:34:52 +00:00
= item *
Christian Loos
2015-07-01 10:31:40 +00:00
= back
= head1 SUPPORT
2015-07-01 11:39:16 +00:00
2015-07-01 10:31:40 +00:00
Bug reports , feature requests , and downloads at http: //m ysqltuner . com /
2015-07-01 11:39:16 +00:00
2015-07-01 10:31:40 +00:00
Bug tracker can be found at https: //gi thub . com /major/ MySQLTuner - perl / issues
2015-07-01 11:39:16 +00:00
2015-07-01 10:31:40 +00:00
Maintained by Major Hayden ( major \ @ mhtx . net ) - Licensed under GPL
= head1 SOURCE CODE
L <https://github.com/major/MySQLTuner-perl>
2015-07-01 11:39:16 +00:00
git clone https: //gi thub . com /major/ MySQLTuner - perl . git
2015-07-01 10:31:40 +00:00
= head1 COPYRIGHT AND LICENSE
Copyright ( C ) 2006 - 2015 Major Hayden - major @ mhtx . net
For the latest updates , please visit http: //m ysqltuner . com /
2015-07-01 11:39:16 +00:00
2015-07-01 10:31:40 +00:00
Git repository available at http: //gi thub . com /major/ MySQLTuner - perl
This program is free software: you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation , either version 3 of the License , or
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
2015-07-01 11:39:16 +00:00
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE .
See the GNU General Public License for more details .
2015-07-01 10:31:40 +00:00
You should have received a copy of the GNU General Public License
along with this program . If not , see <http://www.gnu.org/licenses/> .
= cut
2011-03-08 18:37:58 +00:00
# Local variables:
# indent-tabs-mode: t
# cperl-indent-level: 8
# perl-indent-level: 8
2016-01-27 16:22:49 +00:00
# End:
2016-03-15 09:14:31 +00:00