If you using php-fpm, I would recommend running the following bash script which will give you some vital info on tuning php-fpm:
#! /bin/bash
### Switches
function usage()
{
echo
echo "Usage: php-fpmpal.sh [OPTION]"
echo
echo "Arguments:"
echo " -MB [VALUE] Specify how much memory (in MB) you would like the whole of PHP-FPM to be able to use and base the calculations on this value, rather than on the value worked out by the script"
echo
}
if [ $# != 0 ]; then
if [ $1 == "--help" ]; then
usage
exit 0
fi
fi
### Check if the script is being run with root privileges
if [ $EUID != "0" ]; then
echo "This script must be run as root" 1>&2
echo
echo
exit 1
fi
### Check if bc is installed
bc -v 1> /dev/null 2>&1
if [ $? != 0 ]; then
echo -e "\e[31m\"bc\" is not installed. This script depends on it.\e[0m"
while true; do
echo "Do you wish to install bc? (y/n)"
read yn < /dev/tty
case $yn in
[Yy]* ) python -mplatform | egrep -i 'debian|ubuntu' 2>&1 > /dev/null && apt-get install bc -y -qq || yum install bc -y -q ; break;;
[Nn]* ) exit;;
* ) echo "Please answer yes or no.";;
esac
done
fi
### END OF switches
echo
echo -e "\e[38;5;81m ( ) ( ( ( * "
echo -e "\e[38;5;51m\e[1m )\ ) ( /( )\ ) )\ ) )\ ) ( \` \e[33m\e[1m ( "
echo -e "\e[38;5;45m(()/( )\())(()/( (()/( (()/( )\))( \e[38;5;214m ) )\ "
echo -e "\e[38;5;33m /(_))((_)\ /(_)) /(_)) /(_))((_)()\ \e[38;5;208m \` ) ( /( ((_) "
echo -e "\e[38;5;27m(_)) _((_)(_)) (_))_|(_)) (_()((_) \e[38;5;124m/(/( )(_)) _ "
echo -e "\e[0m\e[38;5;21m| _ \ | || || _ \ ___ | |_ | _ \ | \/ |\e[38;5;88m\e[1m((_)_\ \e[38;5;88m((_)\e[0m\e[38;5;9m_ | | "
echo -ne "\e[38;5;21m| _/ | __ || _/|___|| __| | _/ | |\/| |\e[38;5;9m| '_ \\"
echo -e "\e[38;5;88m\e[1m)\e[0m\e[38;5;9m/ _\` || | "
echo -e "\e[38;5;21m|_| |_||_||_| |_| |_| |_| |_|\e[38;5;9m| .__/ \__,_||_| "
for i in {17..21} {21..17} {17..21} {21..17} {17..21} {21..17} {17..21} {21..17} {17..17} ; do echo -en "\e[38;5;${i}m=\e[0m" ; done
echo -en "\e[38;5;9m |_| "
for i in {17..21} {21..21} {21..21} {21..21} {20..16} ; do echo -en "\e[38;5;${i}m=\e[0m" ; done
echo -e "\e[0m"
echo
echo
### Determine whether the PHP-FPM process is called php-fpm or php5-fpm
phpfpm_installed=0
php-fpm -v 1> /dev/null 2>&1
if [ $? == 0 ]; then
phpfpm_installed=1
fpm_type=`php-fpm -i 2>&1 | grep "SERVER\[\"_\"\]" | cut -d\/ -f4`
fi
php5-fpm -v 1> /dev/null 2>&1
if [ $? == 0 ]; then
phpfpm_installed=1
fpm_type=`php5-fpm -i 2>&1 | grep "SERVER\[\"_\"\]" | cut -d\/ -f4`
fi
### Exit if PHP-FPM is not installed
if [ $phpfpm_installed == 0 ]; then
echo -e "\e[31m!!! PHP-FPM not detected. Exiting. !!!\e[0m"
echo
exit 1
fi
### Check if PHP-FPM is running
ps aux | grep "php-fpm" | grep -v grep | grep -v "php-fpmpal" 1> /dev/null 2>&1
if [ $? == 1 ]; then
echo -e "\e[31m!!! PHP-FPM is installed but not running. PHP-FPM should be started before running this script. Exiting. !!!\e[0m"
echo
exit 1
fi
### VARIABLE INITIALISATION
# Apache root and config file
#apachectl -V 1> /dev/null 2>&1
if [ $(which apachectl | wc -l) != 0 ]; then
httpd_root=`apachectl -V | awk -F "\"" '/HTTPD_ROOT/ {print $2}'`
httpd_config_file=`apachectl -V | awk -F "\"" '/SERVER_CONFIG_FILE/ {print $2}'`
httpd_root_and_config_file=$httpd_root"/"$httpd_config_file
# Apache Includes (only 1 level deep from main configuration file)
httpd_main_include=`awk -v var="$httpd_root" '/^Include/ {print var "/" $2}' $httpd_root_and_config_file`
IFS=$'\n' list_of_apache_includes=($(ls $httpd_main_include))
fi
### Get list of all PHP-FPM pools from process list
IFS=$'\n' list_of_pools=($(ps aux | grep "php-fpm" | grep -v ^root | grep -v grep | awk -F "pool " '{print $2}' | sort | uniq | sed -e 's/ //g'))
### Get total server memory
total_server_memory=`cat /proc/meminfo | grep MemTotal | awk '{print $2}'`
### Initialise variable to tally up total current PHP-FPM memory usage
total_phpfpm_mem_usage=0
### Initialise variable to tally up total potential PHP-FPM memory usage based on largest processes in pool
total_phpfpm_mem_usage_largest_process=0
### Initialise variable to tally up total potential PHP-FPM memory usage based on average process size in pool
total_phpfpm_mem_usage_average_process=0
### Set variable to the total number of PHP-FPM pools
let no_of_pools=(${#list_of_pools[@]}-1)
### Get list of possible configuration files
IFS=$'\n' list_of_includes=($(grep -i ^include `ps aux | egrep "php.*master" | grep -v grep | cut -d\( -f2 | cut -d\) -f1` | cut -d= -f2))
### Set total number of include files
let no_of_includes=(${#list_of_includes[@]}-1)
### Match each pool to its configuration file
for ((p=0; p<=no_of_pools; p++))
do
for ((i=0; i<=no_of_includes; i++ ))
do
grep "\[${list_of_pools[$p]}\]" ${list_of_includes[$i]} > /dev/null
if [ $? == 0 ]; then
pool_config_file[$p]="${list_of_includes[$i]}"
fi
done
done
### Give info re all list of PHP-FPM pools
### ======================================
echo -en "\e[38;5;22m=\e[38;5;28m=\e[38;5;34m=\e[38;5;40m=\e[38;5;46m="
echo -en "\e[32m\e[1m List of PHP-FPM pools \e[0m"
echo -e "\e[38;5;46m=\e[38;5;40m=\e[38;5;34m=\e[38;5;28m=\e[38;5;22m=\e[0m"
### For each pool
for ((i=0; i<=no_of_pools; i++))
do
### Print pool name and configuration file
echo -en "\e[36m\e[1m--- "
echo -en ${list_of_pools[$i]}
echo -e " ---\e[0m"
echo -n "Configuration file: "; echo `grep -H "\[${list_of_pools[$i]}\]" ${pool_config_file[$i]} | cut -d: -f1`
if [ 0 == 1 ]; then
### Find the site(s) that rely on this pool
# Find the socket/TCP listener for this pool
pool_listener=`egrep -i "^listen" ${pool_config_file[$i]} | sed -e 's/ //g' | grep "^listen=" | cut -d= -f2`
# Find the FastCGIExternalServer directive for this socket in the Apache configuration and get the "Alias/Action"
action_alias=`grep -h "FastCGIExternalServer" ${list_of_apache_includes[@]} | grep -v "#" | grep $pool_listener | awk '{print $2}'`
#echo $action_alias
# Find all the vhost files within which the "Alias/Action" is referenced
# First find out whether any sites rely on this pool
grep -H $action_alias ${list_of_apache_includes[@]} | grep Alias | grep -v "#" | awk '{print $4, $1}' | grep "$action_alias " > /dev/null
# If no sites rely on it
if [ $? == 1 ]; then
echo "Site(s) that rely on this pool: None"
# Else if at least one site relies on it
else
IFS=$'\n' vhost_name=($(grep -H $action_alias ${list_of_apache_includes[@]} | grep Alias | grep -v "#" | awk '{print $4, $1}' | grep "$action_alias " | awk '{print $2}' | cut -d: -f1))
#echo ${vhost_name[@]}
# As there may be multiple vhosts in the file, we want to extract just the vhost within which the "Alias/Action" was referenced
echo "" > temp_filelist
echo "" > filelist
#action_line_nr=`grep -hn $action_alias$ ${list_of_apache_includes[@]} | grep Alias | grep -v "#" | cut -d: -f1`
#echo $action_line_nr >> temp_filelist
let no_of_vhosts_that_rely_on_this_pool=(${#vhost_name[@]}-1)
#echo ${vhost_name[@]}
#echo -n "nr_of_vhosts: "
#echo $no_of_vhosts_that_rely_on_this_pool
#nr_of_vhost_name=${#vhost_name[@]}
#let nr_of_vhost_name=(${#vhost_name[@]}-1)
#echo $nr_of_vhost_name
# for every vhosts pull out the sitename
echo -n "Site(s) that rely on this pool: "
#for a in ${nr_of_vhost_name[@]} ###
#for ((i=0; i<=no_of_vhosts_that_rely_on_this_pool; i++))
for ((i=0; i<=no_of_vhosts_that_rely_on_this_pool; i++))
#for ((i=0; i<=1; i++))
do ###
action_line_nr=`grep -hn $action_alias$ ${vhost_name[$i]} | grep Alias | grep -v "#" | cut -d: -f1`
echo $action_line_nr >> temp_filelist
egrep -n "<VirtualHost|</VirtualHost" ${vhost_name[$i]} | grep -v "#" | cut -d: -f1 >> temp_filelist
sort -n temp_filelist > filelist
vhost_start_line=`grep -B1 $action_line_nr filelist | head -1`
vhost_end_line=`grep -A1 $action_line_nr filelist | tail -1`
rm -rf filelist
rm -rf temp_filelist
site_name=`sed -n "$vhost_start_line,$vhost_end_line p" ${vhost_name[$i]} | grep ServerName | awk '{print $2}'`
echo -ne "\e[36m\e[1m$site_name\e[0m "
done ###
echo
fi
fi
### ROLLBACK
if [ 0 == 1 ]; then
### Find the site(s) that rely on this pool
# Find the socket/TCP listener for this pool
pool_listener=`egrep -i "^listen" ${pool_config_file[$i]} | sed -e 's/ //g' | grep "^listen=" | cut -d= -f2`
# Find the FastCGIExternalServer directive for this socket in the Apache configuration and get the "Alias/Action"
action_alias=`grep -h "FastCGIExternalServer" ${list_of_apache_includes[@]} | grep -v "#" | grep $pool_listener | awk '{print $2}'`
# Find the vhost file within which the "Alias/Action" is referenced
vhost_name=`grep -H $action_alias ${list_of_apache_includes[@]} | grep Alias | cut -d: -f1`
# As there may be multiple vhosts in the file, we want to extract just the vhost within which the "Alias/Action" was referenced
echo "" > temp_filelist
echo "" > filelist
action_line_nr=`grep -hn $action_alias ${list_of_apache_includes[@]} | grep Alias | cut -d: -f1`
echo $action_line_nr >> temp_filelist
egrep -n "<VirtualHost|</VirtualHost" $vhost_name | grep -v "#" | cut -d: -f1 >> temp_filelist
sort -n temp_filelist > filelist
vhost_start_line=`grep -B1 $action_line_nr filelist | head -1`
vhost_end_line=`grep -A1 $action_line_nr filelist | tail -1`
rm -rf filelist
rm -rf temp_filelist
echo -n "Site(s) that rely on this pool: "
site_name=`sed -n "$vhost_start_line,$vhost_end_line p" $vhost_name | grep ServerName | awk '{print $2}'`
echo -e "\e[36m$site_name\e[0m"
fi
### /ROLLBACK
### Create a list of process IDs that belong to this pool
IFS=$'\n' list_of_pids=($(ps aux | grep "php-fpm" | grep -v ^root | grep -v grep | grep pool | awk '{print $2, $13}' | grep " ${list_of_pools[$i]}$" | awk '{print $1}'))
### List all process IDs that belong to this pool
echo -n "List of processes: "
echo ${list_of_pids[@]}
### List total number of processes that belong to this pool
echo -n "Number of processes: "
echo ${#list_of_pids[@]}
### Get the current max_children value
echo -n "Current max_children value: "
current_max_children_value=`grep "^pm.max_children" ${pool_config_file[$i]} | cut -d= -f2 | sed -e 's/ //g' | tail -1`
echo $current_max_children_value
### Calculate the total memory usage for this pool
total_pool_mem_usage[$i]=0
### For each process
for a in "${list_of_pids[@]}"
do
### Gather memory usage (using pmap) and add it to total_pool_mem_usage variable
let total_pool_mem_usage[$i]+=`pmap -d $a | grep "writeable/private" | awk '{ print $4 }' | sed -e s/K//`
done
### Print total memory usage for this pool
echo -n "Total memory usage for pool in KB: "
echo ${total_pool_mem_usage[$i]}
### Increase the total PHP-FPM memory usage with the total memory usage for this pool
let total_phpfpm_mem_usage+=${total_pool_mem_usage[$i]}
### Calculate the average process memory usage for this pool
echo -n "Average memory usage per process in KB: "
pool_ave_process_size[$i]=`echo "${total_pool_mem_usage[$i]} / ${#list_of_pids[@]}" | bc`
echo ${pool_ave_process_size[$i]}
### Total potential memory usage for pool based on average process size: max_children * average process size
echo -n "Total potential memory usage for pool (based on average process) (KB): "
potential_mem_usage=`echo "$current_max_children_value * ${pool_ave_process_size[$i]}" | bc`
let total_phpfpm_mem_usage_average_process+=$potential_mem_usage
echo $potential_mem_usage
### Get the largest pool process size
echo -n "Largest process in this pool is (KB): "
for a in "${list_of_pids[@]}"
do
pool_processes_mem_size[$a]=`pmap -d $a | grep "writeable/private" | awk '{ print $4 }' | sed -e s/K// | sort -nr | head -1 | sort -nr | head -1`
done
let largest_pool_process_size=`echo "${pool_processes_mem_size[*]}" | sort -nr | head -1`
echo $largest_pool_process_size
### Total potential memory usage for pool based on largest process size: max_children * largest process size
echo -n "Total potential memory usage for pool (based on largest process) (KB): "
potential_mem_usage=`echo "$current_max_children_value * $largest_pool_process_size" | bc`
let total_phpfpm_mem_usage_largest_process+=$potential_mem_usage
echo $potential_mem_usage
echo
done
### END OF Give info re all list of PHP-FPM pools
### =============================================
### Print out statistics re server memory usage
### ===========================================
echo -en "\e[38;5;22m=\e[38;5;28m=\e[38;5;34m=\e[38;5;40m=\e[38;5;46m="
echo -en "\e[32m\e[1m Server memory usage statistics \e[0m"
echo -e "\e[38;5;46m=\e[38;5;40m=\e[38;5;34m=\e[38;5;28m=\e[38;5;22m=\e[0m"
### Total server memory
echo -ne "Total server memory in KB: "
echo -e "$total_server_memory"
### Calculate total Apache memory usage
echo -n " =Total Apache memory usage in KB: "
# If Apache is installed
apachectl -V 1> /dev/null 2>&1
if [ $? == 0 ]; then
### Gather the process name for Apache (httpd for RHEL/CentOS; apache2 for Ubuntu
apache_process_name=`apachectl -V 2>&1 | grep PID | awk -F"run/" '{print $2}' | cut -d. -f1`
### If Apache is running
ps aux | grep -v ^root | egrep $apache_process_name > /dev/null
if [ $? == 0 ]; then
### Get a list of all Apache process IDs
IFS=$'\n' list_of_apache_pids=($(ps aux | grep $apache_process_name | grep -v ^root | grep -v grep | awk '{print $2}'))
total_apache_pool_mem_usage=0
### Add the memory usage for that process to the total Apache memory usage
for a in "${list_of_apache_pids[@]}"
do
let total_apache_pool_mem_usage+=`pmap -d $a | grep "writeable/private" | awk '{ print $4 }' | sed -e s/K//`
done
### Else if Apache is not running set total Apache memory usage to 0
else
total_apache_pool_mem_usage=0
fi
else
total_apache_pool_mem_usage=0
fi
echo $total_apache_pool_mem_usage
### Calculate total nginx memory usage
echo -n " =Total nginx memory usage in KB: "
nginx -v 1> /dev/null 2>&1
# If nginx is installed
if [ $? == 0 ]; then
IFS=$'\n' list_of_nginx_pids=($(ps aux | grep -i nginx | grep -v ^root | grep -v grep | awk '{print $2}'))
total_nginx_mem_usage=0
### Add the memort usage for that process to the total nginx memory usage
for a in "${list_of_nginx_pids[@]}"
do
let total_nginx_mem_usage+=`pmap -d $a | grep "writeable/private" | awk '{ print $4 }' | sed -e s/K//`
done
# else if nginx is not installed
else
total_nginx_mem_usage=0
fi
echo $total_nginx_mem_usage
### Calculate total Varnish memory usage
echo -n " =Total Varnish memory usage in KB: "
### If Varnish is running
ps aux | grep -v ^root | grep varnish > /dev/null
if [ $? == 0 ]; then
### Get Varnish's % memory usage from ps (I've found this more reliable than using pmap
varnish_perc=`ps aux | grep -v ^root | grep varnish | awk '{print $4}'`
### Calculate total Varnish memory usage
total_varnish_mem_usage=`echo "$total_server_memory / 100 * $varnish_perc" | bc`
### Else if Varnish is not running set total Varnish memory usage to 0
else
total_varnish_mem_usage=0
fi
echo $total_varnish_mem_usage
### Calculate total MySQL memory usage
echo -n " =Total MySQL memory usage in KB: "
### If MySQL is running
ps aux | grep -v ^root | grep mysql > /dev/null
if [ $? == 0 ]; then
### Get MySQL's % memory usage from ps (I've found this more reliable than using pmap
mysql_perc=`ps aux | grep -v ^root | grep mysql | awk '{print $4}'`
### Calculate total MySQL memory usage
total_mysql_pool_mem_usage=`echo "$total_server_memory / 100 * $mysql_perc" | bc`
### Else if MySQL is not running set total MySQL memory usage to 0
else
total_mysql_pool_mem_usage=0
fi
echo $total_mysql_pool_mem_usage
### Print total current PHP-FPM memory usage
echo -n " =Total PHP-FPM memory usage in KB: "
echo $total_phpfpm_mem_usage
echo
# Calculate total memory available to assign to PHP-FPM
echo -n "Memory available to assign to PHP-FPM pools in KB: "
### Total memory usage - (the sum of all other processes listed above)
### Take total free memory and add current PHP-FPM total memory usage
# RHEL 7's free reports look different to CentOS6, Ubuntu 14 and Debian 8 so I have to 1) check whether this is RHEL/CentOS 7, and 2) if it is, use different formulas
rhel7_check=0
if [ -f /etc/redhat-release ]; then
rhel7_check=`grep -v ^# /etc/redhat-release | awk -F "release" '{print $2}' | awk '{print $1}' | cut -d. -f1` > /dev/null
fi
# If this is RHEL 7 then use this formula
if [ $rhel7_check == '7' ]; then
total_phpfpm_allowed_memory=$(echo "`free -k | awk '/Mem/ {print $7}'` + $total_phpfpm_mem_usage" | bc)
# If this is not RHEL 7 use this formula
else
total_phpfpm_allowed_memory=$(echo "`free -k | awk '/buffers\/cache/ {print $4}'` + $total_phpfpm_mem_usage" | bc)
fi
# If the user has specified that they will set the available PHP-FPM memory themselves
if [ $# != 0 ]; then
# then print out user-specified value
if [ $1 == "-MB" ]; then
total_phpfpm_allowed_memory=`echo "$2*1024" | bc`
echo -n $total_phpfpm_allowed_memory
echo " (user-specified)"
fi
# Otherwise print out script-calculate value
else
echo -n $total_phpfpm_allowed_memory
echo " (total free memory + PHP-FPM's current memory usage)"
fi
echo
### Print out total potential PHP-FPM usage based on largest process size per pool
echo -n "Total potential PHP-FPM memory usage based on largest processes (KB): "
echo -n $total_phpfpm_mem_usage_largest_process
echo -ne "\e[33m (`echo "scale=2; $total_phpfpm_mem_usage_largest_process*100/$total_phpfpm_allowed_memory" | bc `"
echo -n "%)"
# Print warning if this is larger than allowed PHP-FPM memory usage
if [ $total_phpfpm_mem_usage_largest_process -gt $total_phpfpm_allowed_memory ]; then
echo -e " \e[31m!!! THIS IS LARGER THAN THE ASSIGNED MEMORY USAGE !!!\e[0m"
else
echo -e " \e[32m...GOOD :-)\e[0m"
fi
### Print out total potential PHP-FPM usage based on average process size per pool
echo -n "Total potential PHP-FPM memory usage based on average process size (KB): "
echo -n $total_phpfpm_mem_usage_average_process
echo -ne "\e[33m (`echo "scale=2; $total_phpfpm_mem_usage_average_process*100/$total_phpfpm_allowed_memory" | bc `"
echo -n "%)"
# Print warning if this is larger than allowed PHP-FPM memory usage
if [ $total_phpfpm_mem_usage_average_process -gt $total_phpfpm_allowed_memory ]; then
echo -e " \e[31m!!! THIS IS LARGER THAN THE ASSIGNED MEMORY USAGE !!!\e[0m"
else
echo -e " \e[32m...GOOD :-)\e[0m"
fi
echo
### END OF Print out statistics re server memory usage
### ==================================================
### Calculate and display recommendations for every PHP-FPM pool
### ============================================================
echo -en "\e[38;5;22m=\e[38;5;28m=\e[38;5;34m=\e[38;5;40m=\e[38;5;46m="
echo -en "\e[32m\e[1m Recommendations per pool \e[0m"
echo -e "\e[38;5;46m=\e[38;5;40m=\e[38;5;34m=\e[38;5;28m=\e[38;5;22m=\e[0m"
### For every PHP-FPM pool
for ((i=0; i<=no_of_pools; i++))
do
### Calculate percentage of memory that pool is using against total PHP-FPM memory usage
pool_perc_mem_use[$i]=`echo "scale=2; ${total_pool_mem_usage[$i]}*100/$total_phpfpm_mem_usage" | bc`
### Take that percentage and divide it by the total memory that should be available for PHP-FPM to use to get the total "allowed" memory usage for this pool
pool_allowed_mem_use[$i]=`echo "$total_phpfpm_allowed_memory * ${pool_perc_mem_use[$i]} / 100" | bc`
### Divide the average process size for this pool by the total "allowed" memory usage for this pool to get a recommended max_children value
pool_allowed_max_children[$i]=`echo "${pool_allowed_mem_use[$i]} / ${pool_ave_process_size[$i]}" | bc`
### Get the current max_children value for this PHP-FPM pool
current_max_children_value=`grep "^pm.max_children" ${pool_config_file[$i]} | cut -d= -f2 | sed -e 's/ //g' | tail -1`
### Print out all this information
echo -e "\e[36m\e[1m-- ${list_of_pools[$i]} --\e[0m currently uses ${total_pool_mem_usage[$i]} KB memory (\e[33m${pool_perc_mem_use[$i]}%\e[0m of all PHP-FPM memory usage). It should be allowed to use about ${pool_allowed_mem_use[$i]} KB of all available memory. Its average process size is ${pool_ave_process_size[$i]} KB so this means \e[38;5;208mmax_children should be set to ~\e[1m${pool_allowed_max_children[$i]}\e[0m. It is currently set to $current_max_children_value (this can be changed in ${pool_config_file[$i]})."
done
echo
### END OF Calculate and display recommendations for every PHP-FPM pool
### ===================================================================
### Other considerations
### ====================
echo -en "\e[38;5;22m=\e[38;5;28m=\e[38;5;34m=\e[38;5;40m=\e[38;5;46m="
echo -en "\e[32m\e[1m Other considerations to take into account \e[0m"
echo -e "\e[38;5;46m=\e[38;5;40m=\e[38;5;34m=\e[38;5;28m=\e[38;5;22m=\e[0m"
# Find PHP-FPM main configuration file
main_phpfpm_config_file=`ps aux | grep "php-fpm: master process" | grep -v grep | awk -F 'process' '{print $2}' | sed -e 's/[() ]//g'`
# Get error log location from main configuration file
error_log_location=`grep "^error_log" $main_phpfpm_config_file | awk '{print $3}'`
# Find out whether there were any max_children errors in the logs
errors_in_logs=`zgrep "server reached pm.max_children" $error_log_location* | wc -l` > /dev/null
# If there were max_children errors
if [ $errors_in_logs != 0 ]; then
# Print out consideration regarding this
echo "From the PHP-FPM error logfiles ($error_log_location):"
zgrep "server reached pm.max_children" $error_log_location* | awk '{print $5, $10}' | sed -e 's/[(),]//g' | sed -e 's/\]//g' | sort | uniq -c | awk '{print " - pool \033[36m" $2 "\033[0m had reached its max_children value of " $3 " on " $1 " occasion(s)"}'
echo
echo "For these pools you may want to compare the recommended max_children value to this information, and decide whether the recommended value would be high enough to prevent max_children from being hit in future."
# Else print that there are no further recommendations
else
echo "No other recommendations at this stage."
fi
# PHP-FPMpal usage
echo
echo "Note: It is not ideal to run PHP-FPMpal shortly after restarting PHP-FPM or your webservices. This is because PHP-FPMpal makes recommendations based on the average pool process size, and if PHP-FPM was restarted a short while ago then the likelihood is high that there won't have been many requests made to the sites since the restart, and metrics will be skewed and not show a normalised average."
echo "It is also worth noting that if you've recently restarted any services that normally use up a large amount of memory then you probably want to wait a while before running PHP-FPMpal (e.g. if MySQL normally uses 50% of memory, but you've just restarted it then it may only use 10% of memory right now, thus the recommendations will be very skewed)."
echo
### END OF Other considerations
### ===========================
for i in {17..21} {21..17} {17..21} {21..17} {17..21} {21..17} {17..21} {21..17} {17..21} {21..17} {17..21} {21..17} ; do echo -en "\e[38;5;${i}m=\e[0m" ; done
echo -e "\e[0m"
echo
No token or token has expired.