cschantz
096a2d795f
ROOT CAUSE: The batch analyzer calls calculate_optimal_php_settings() which relies on calculate_max_children_memory_based(). When no active PHP-FPM processes exist (common in ondemand mode with sparse traffic), both functions returned 0. IMPACT: - Recommending pm.max_children: 0 (completely invalid, breaks PHP-FPM) - Causes silent failures in optimization reports - Especially problematic with ondemand PM mode + low traffic domains FIXES: 1. calculate_max_children_memory_based(): • When no processes detected: return 20 instead of 0 • When invalid parameters: return 20 instead of 0 2. calculate_optimal_php_settings(): • Added CRITICAL safety check: if final_max_children <= 0, use 20 • Ensures output is always safe regardless of calculation errors DEFAULTS: - Memory-based: 20 (safe minimum when no process data available) - Traffic-based: Uses actual peak concurrent if available - Safety guardrail: 20 minimum in all code paths This prevents invalid recommendations and ensures batch analyzer always provides sensible, actionable optimization guidance. Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
403 lines
15 KiB
Bash
403 lines
15 KiB
Bash
#!/bin/bash
|
|
################################################################################
|
|
# PHP-FPM Calculator - Improved Algorithm
|
|
# Purpose: Calculate optimal PHP-FPM pool settings based on:
|
|
# - Available server memory
|
|
# - Actual traffic patterns (peak concurrent requests)
|
|
# - Other service memory usage (MySQL, Redis, etc)
|
|
# - PM mode recommendations
|
|
# - Safe allocation buffers based on traffic stability
|
|
################################################################################
|
|
|
|
# Dependencies
|
|
_LIB_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
source "$_LIB_DIR/php-detector.sh" 2>/dev/null || { echo "ERROR: php-detector.sh not found"; return 1; }
|
|
source "$_LIB_DIR/system-detect.sh" 2>/dev/null || { echo "ERROR: system-detect.sh not found"; return 1; }
|
|
|
|
# ============================================================================
|
|
# HELPER FUNCTION - Extract field from pipe-delimited string
|
|
# ============================================================================
|
|
get_field() {
|
|
local input="$1"
|
|
local field_num="$2"
|
|
local temp="$input"
|
|
local i=1
|
|
|
|
while [ $i -lt "$field_num" ]; do
|
|
temp="${temp#*|}"
|
|
i=$((i + 1))
|
|
done
|
|
|
|
echo "${temp%%|*}"
|
|
}
|
|
|
|
# ============================================================================
|
|
# IMPROVED: SYSTEM RESERVE CALCULATION
|
|
# ============================================================================
|
|
# Calculate system reserve based on total RAM (percentage-based, not hardcoded)
|
|
# Usage: calculate_system_reserve <total_ram_mb>
|
|
# Returns: reserved_mb|reason
|
|
calculate_system_reserve() {
|
|
local total_ram_mb="$1"
|
|
|
|
if [ -z "$total_ram_mb" ] || [ "$total_ram_mb" -lt 512 ]; then
|
|
echo "256|Minimal system (< 512MB RAM)"
|
|
return
|
|
fi
|
|
|
|
local reserved_mb
|
|
|
|
# Dynamic reserve based on total RAM:
|
|
# Small servers (< 2GB): 15% reserve (keep base system stable)
|
|
# Medium servers (2-8GB): 20% reserve (typical workload)
|
|
# Large servers (8-32GB): 25% reserve (headroom for spikes)
|
|
# Very large servers (> 32GB): 30% reserve (accommodate multiple services)
|
|
|
|
if [ "$total_ram_mb" -lt 2048 ]; then
|
|
# Small VPS: 15% reserve
|
|
reserved_mb=$((total_ram_mb * 15 / 100))
|
|
[ "$reserved_mb" -lt 256 ] && reserved_mb=256
|
|
echo "$reserved_mb|Small server reserve (15% of ${total_ram_mb}MB)"
|
|
elif [ "$total_ram_mb" -lt 8192 ]; then
|
|
# Medium: 20% reserve
|
|
reserved_mb=$((total_ram_mb * 20 / 100))
|
|
echo "$reserved_mb|Medium server reserve (20% of ${total_ram_mb}MB)"
|
|
elif [ "$total_ram_mb" -lt 32768 ]; then
|
|
# Large: 25% reserve
|
|
reserved_mb=$((total_ram_mb * 25 / 100))
|
|
echo "$reserved_mb|Large server reserve (25% of ${total_ram_mb}MB)"
|
|
else
|
|
# Very large: 30% reserve
|
|
reserved_mb=$((total_ram_mb * 30 / 100))
|
|
echo "$reserved_mb|Very large server reserve (30% of ${total_ram_mb}MB)"
|
|
fi
|
|
}
|
|
|
|
# ============================================================================
|
|
# IMPROVED: MEMORY-BASED MAX_CHILDREN (Refined Algorithm)
|
|
# ============================================================================
|
|
# Calculate max_children based on available memory and safety buffer
|
|
# Usage: calculate_max_children_memory_based <username> <total_ram_mb>
|
|
# Returns: max_children|reason
|
|
calculate_max_children_memory_based() {
|
|
local username="$1"
|
|
local total_ram_mb="$2"
|
|
|
|
if [ -z "$total_ram_mb" ] || [ -z "$username" ]; then
|
|
echo "20|Invalid parameters"
|
|
return
|
|
fi
|
|
|
|
# Get average memory per process
|
|
local avg_kb
|
|
avg_kb=$(get_fpm_memory_usage "$username" 2>/dev/null || echo "0")
|
|
|
|
if [ "$avg_kb" -eq 0 ]; then
|
|
# No active processes detected (ondemand mode, or low traffic)
|
|
# Use safe default: 20 processes with assumed 50MB per process
|
|
echo "20|No active processes, using safe default"
|
|
return
|
|
fi
|
|
|
|
# Calculate system reserve (dynamic percentage-based)
|
|
local reserve_result
|
|
reserve_result=$(calculate_system_reserve "$total_ram_mb")
|
|
local reserved_mb
|
|
reserved_mb=$(get_field "$reserve_result" 1)
|
|
|
|
# Available memory for PHP-FPM
|
|
local available_mb=$((total_ram_mb - reserved_mb))
|
|
|
|
# Convert average KB to MB
|
|
local avg_mb=$((avg_kb / 1024))
|
|
if [ "$avg_mb" -eq 0 ]; then
|
|
avg_mb=1 # Minimum 1MB to prevent division issues
|
|
fi
|
|
|
|
# Theoretical maximum without safety buffer
|
|
local theoretical_max=$((available_mb / avg_mb))
|
|
|
|
# Apply safety buffer (default 15%, refined later based on traffic patterns)
|
|
local safety_buffer=15
|
|
local recommended=$((theoretical_max * (100 - safety_buffer) / 100))
|
|
|
|
# Sanity checks
|
|
if [ "$recommended" -lt 2 ]; then
|
|
echo "2|Minimum safe value (insufficient memory)"
|
|
elif [ "$recommended" -gt 500 ]; then
|
|
# Cap at 500 (typical proxy upstream pool size)
|
|
echo "500|Capped at safe maximum (would be $recommended)"
|
|
else
|
|
local reason="Memory-based: ${avg_mb}MB per process, ${available_mb}MB available, ${safety_buffer}% buffer"
|
|
echo "$recommended|$reason"
|
|
fi
|
|
}
|
|
|
|
# ============================================================================
|
|
# NEW: TRAFFIC-BASED MAX_CHILDREN CALCULATION
|
|
# ============================================================================
|
|
# Calculate max_children based on actual peak concurrent requests
|
|
# Usage: calculate_peak_concurrent_requests <username> <days>
|
|
# Returns: peak_concurrent|stability_factor
|
|
calculate_peak_concurrent_requests_improved() {
|
|
local username="$1"
|
|
local days="${2:-7}"
|
|
|
|
# Find access logs
|
|
local access_logs
|
|
access_logs=$(find /home/"$username"/*/logs -name "access_log*" -o -name "access.log*" 2>/dev/null | head -5)
|
|
|
|
if [ -z "$access_logs" ]; then
|
|
echo "0|0.8|No access logs found"
|
|
return
|
|
fi
|
|
|
|
# Analyze access logs to find peak concurrent requests
|
|
# Strategy: Use combined timestamp analysis for better accuracy
|
|
local peak_concurrent=0
|
|
local total_samples=0
|
|
local high_traffic_periods=0
|
|
local traffic_variance=0
|
|
|
|
# Sample each log and find peaks
|
|
while IFS= read -r log_file; do
|
|
[ ! -f "$log_file" ] && continue
|
|
|
|
# Get logs from last N days
|
|
local temp_processed
|
|
temp_processed=$(find "$log_file" -mtime -"$days" -exec tail -n 10000 {} \; 2>/dev/null | \
|
|
awk '{print $4}' | sed 's/\[//' | sort | uniq -c | sort -rn | head -1)
|
|
|
|
if [ -n "$temp_processed" ]; then
|
|
local sample_count
|
|
sample_count=$(echo "$temp_processed" | awk '{print $1}')
|
|
if [ "$sample_count" -gt "$peak_concurrent" ]; then
|
|
peak_concurrent=$sample_count
|
|
fi
|
|
total_samples=$((total_samples + 1))
|
|
fi
|
|
done <<< "$access_logs"
|
|
|
|
# If no samples, estimate from HTTP status codes
|
|
if [ "$total_samples" -eq 0 ]; then
|
|
# Estimate: count 200 responses per second at peak
|
|
peak_concurrent=$(tail -n 100000 "$log_file" 2>/dev/null | grep " 200 " | wc -l | awk '{print int($1/100)}')
|
|
if [ "$peak_concurrent" -lt 1 ]; then
|
|
peak_concurrent=1
|
|
fi
|
|
fi
|
|
|
|
# Estimate traffic stability (0.6 = unstable, 0.8 = stable, 0.9 = very stable)
|
|
# This is used to adjust safety buffer
|
|
local stability_factor=0.8
|
|
if [ "$total_samples" -lt 3 ]; then
|
|
stability_factor=0.6 # Very limited data, assume unstable
|
|
elif [ "$total_samples" -ge 10 ]; then
|
|
stability_factor=0.9 # Good data, assume stable
|
|
fi
|
|
|
|
echo "$peak_concurrent|$stability_factor|Based on $total_samples access logs"
|
|
}
|
|
|
|
# ============================================================================
|
|
# NEW: RECOMMEND MAX_CHILDREN from TRAFFIC PATTERNS
|
|
# ============================================================================
|
|
# Calculate recommended max_children based on peak concurrent requests
|
|
# Usage: calculate_max_children_traffic_based <peak_concurrent> <stability_factor>
|
|
# Returns: recommended_max_children|reason
|
|
calculate_max_children_traffic_based() {
|
|
local peak_concurrent="$1"
|
|
local stability_factor="${2:-0.8}"
|
|
|
|
if [ "$peak_concurrent" -lt 1 ]; then
|
|
echo "5|Insufficient traffic data, using minimum"
|
|
return
|
|
fi
|
|
|
|
# Formula: recommended = peak_concurrent * (1.0 + headroom_factor) * stability_factor
|
|
# headroom_factor: extra capacity for unexpected spikes (default 0.3 = 30%)
|
|
local headroom_factor=0.3
|
|
local recommended=$(echo "$peak_concurrent (1 + $headroom_factor) * $stability_factor" | bc | awk '{print int($1)}')
|
|
|
|
# Sanity bounds
|
|
if [ "$recommended" -lt 5 ]; then
|
|
recommended=5
|
|
elif [ "$recommended" -gt 200 ]; then
|
|
recommended=200 # Most domains don't need more than 200 concurrent processes
|
|
fi
|
|
|
|
local reason="Traffic-based: $peak_concurrent peak concurrent requests"
|
|
if [ "$stability_factor" != "0.8" ]; then
|
|
reason="$reason (stability factor: $stability_factor)"
|
|
fi
|
|
|
|
echo "$recommended|$reason"
|
|
}
|
|
|
|
# ============================================================================
|
|
# NEW: DETECT MYSQL MEMORY USAGE
|
|
# ============================================================================
|
|
# Get MySQL memory usage to account for in PHP-FPM allocation
|
|
# Usage: detect_mysql_memory_usage
|
|
# Returns: mysql_memory_mb|status
|
|
detect_mysql_memory_usage() {
|
|
if ! command -v mysql &>/dev/null && ! command -v mysqld &>/dev/null; then
|
|
echo "0|MySQL not installed"
|
|
return
|
|
fi
|
|
|
|
# Try to get MySQL process memory usage
|
|
local mysql_mem
|
|
mysql_mem=$(ps aux | grep "[m]ysqld" | awk '{print int($6/1024)}')
|
|
|
|
if [ -z "$mysql_mem" ] || [ "$mysql_mem" -eq 0 ]; then
|
|
# Fallback: estimate from MySQL variables
|
|
if command -v mysql &>/dev/null; then
|
|
mysql_mem=$(mysql -e "SHOW VARIABLES LIKE '%buffer%'" 2>/dev/null | grep -i "buffer" | \
|
|
awk -F'\t' '{gsub(/[KM]/,"",$3); if($3 ~ /K/) $3=$3/1024; print $3}' | \
|
|
awk '{sum+=$1} END {print int(sum)}')
|
|
fi
|
|
fi
|
|
|
|
if [ -z "$mysql_mem" ] || [ "$mysql_mem" -eq 0 ]; then
|
|
# Safe default estimate: 300MB for typical MySQL
|
|
echo "300|Estimated default"
|
|
else
|
|
echo "$mysql_mem|Detected from process"
|
|
fi
|
|
}
|
|
|
|
# ============================================================================
|
|
# NEW: RECOMMEND PM MODE (static/dynamic/ondemand)
|
|
# ============================================================================
|
|
# Recommend most appropriate PHP-FPM pm mode based on traffic pattern
|
|
# Usage: recommend_pm_mode <peak_concurrent> <average_concurrent> <stability_factor>
|
|
# Returns: pm_mode|min_spare|max_spare|reason
|
|
recommend_pm_mode() {
|
|
local peak_concurrent="$1"
|
|
local average_concurrent="${2:-$(echo "$peak_concurrent / 2" | bc)}"
|
|
local stability_factor="${3:-0.8}"
|
|
|
|
# Determine stability level
|
|
local traffic_pattern
|
|
if [ "$(echo "$stability_factor < 0.65" | bc)" -eq 1 ]; then
|
|
traffic_pattern="UNSTABLE"
|
|
elif [ "$(echo "$stability_factor < 0.85" | bc)" -eq 1 ]; then
|
|
traffic_pattern="MODERATE"
|
|
else
|
|
traffic_pattern="STABLE"
|
|
fi
|
|
|
|
# Recommend mode based on traffic characteristics
|
|
local pm_mode min_spare max_spare reason
|
|
|
|
if [ "$peak_concurrent" -lt 5 ]; then
|
|
# Very low traffic: ondemand saves memory
|
|
pm_mode="ondemand"
|
|
min_spare=0
|
|
max_spare=3
|
|
reason="Very low traffic ($peak_concurrent peak concurrent)"
|
|
elif [ "$traffic_pattern" = "UNSTABLE" ]; then
|
|
# Unstable traffic: dynamic gives best balance
|
|
pm_mode="dynamic"
|
|
min_spare=$((peak_concurrent / 4))
|
|
max_spare=$((peak_concurrent * 3 / 4))
|
|
reason="Unstable traffic pattern (stability: $stability_factor)"
|
|
elif [ "$traffic_pattern" = "STABLE" ]; then
|
|
# Stable high traffic: static for performance
|
|
pm_mode="static"
|
|
min_spare=$((peak_concurrent - 2))
|
|
max_spare=$((peak_concurrent + 2))
|
|
reason="Stable traffic pattern (peak: $peak_concurrent concurrent)"
|
|
else
|
|
# Moderate/mixed traffic: dynamic is good default
|
|
pm_mode="dynamic"
|
|
min_spare=$((peak_concurrent / 3))
|
|
max_spare=$((peak_concurrent * 2 / 3))
|
|
reason="Moderate traffic ($traffic_pattern)"
|
|
fi
|
|
|
|
# Sanity bounds
|
|
[ "$min_spare" -lt 1 ] && min_spare=1
|
|
[ "$max_spare" -lt "$min_spare" ] && max_spare=$((min_spare + 2))
|
|
[ "$max_spare" -gt 100 ] && max_spare=100
|
|
|
|
echo "$pm_mode|$min_spare|$max_spare|$reason"
|
|
}
|
|
|
|
# ============================================================================
|
|
# NEW: COMPREHENSIVE RECOMMENDATION
|
|
# ============================================================================
|
|
# Calculate optimal settings combining memory and traffic analysis
|
|
# Usage: calculate_optimal_php_settings <username> <total_ram_mb>
|
|
# Returns: max_children|pm_mode|min_spare|max_spare|reason
|
|
calculate_optimal_php_settings() {
|
|
local username="$1"
|
|
local total_ram_mb="$2"
|
|
|
|
if [ -z "$username" ] || [ -z "$total_ram_mb" ]; then
|
|
echo "0|dynamic|1|5|Invalid parameters"
|
|
return
|
|
fi
|
|
|
|
# Calculate memory-based recommendation
|
|
local memory_result
|
|
memory_result=$(calculate_max_children_memory_based "$username" "$total_ram_mb")
|
|
local memory_based_max
|
|
memory_based_max=$(get_field "$memory_result" 1)
|
|
|
|
# Calculate traffic-based recommendation
|
|
local traffic_result
|
|
traffic_result=$(calculate_peak_concurrent_requests_improved "$username" 7)
|
|
local peak_concurrent stability_factor
|
|
peak_concurrent=$(get_field "$traffic_result" 1)
|
|
stability_factor=$(get_field "$traffic_result" 2)
|
|
|
|
local traffic_based_max=0
|
|
if [ "$peak_concurrent" -gt 0 ]; then
|
|
local traffic_calc
|
|
traffic_calc=$(calculate_max_children_traffic_based "$peak_concurrent" "$stability_factor")
|
|
traffic_based_max=$(get_field "$traffic_calc" 1)
|
|
fi
|
|
|
|
# Combine both recommendations (use lower value for safety)
|
|
local final_max_children="$memory_based_max"
|
|
local reason_prefix="Memory-based"
|
|
|
|
if [ "$traffic_based_max" -gt 0 ] && [ "$traffic_based_max" -lt "$memory_based_max" ]; then
|
|
final_max_children="$traffic_based_max"
|
|
reason_prefix="Traffic-based (constrained by memory)"
|
|
elif [ "$traffic_based_max" -gt 0 ]; then
|
|
reason_prefix="Combined (memory: $memory_based_max, traffic: $traffic_based_max)"
|
|
fi
|
|
|
|
# CRITICAL: Ensure we never recommend 0 or invalid values
|
|
if [ -z "$final_max_children" ] || [ "$final_max_children" -le 0 ]; then
|
|
final_max_children="20"
|
|
reason_prefix="Safe default (calculation failed or returned invalid value)"
|
|
fi
|
|
|
|
# Recommend pm mode
|
|
local pm_result
|
|
pm_result=$(recommend_pm_mode "$peak_concurrent" "$((peak_concurrent / 2))" "$stability_factor")
|
|
local pm_mode min_spare max_spare pm_reason
|
|
pm_mode=$(get_field "$pm_result" 1)
|
|
min_spare=$(get_field "$pm_result" 2)
|
|
max_spare=$(get_field "$pm_result" 3)
|
|
pm_reason=$(get_field "$pm_result" 4)
|
|
|
|
echo "$final_max_children|$pm_mode|$min_spare|$max_spare|$reason_prefix: $pm_reason"
|
|
}
|
|
|
|
# ============================================================================
|
|
# Export functions for use in other scripts
|
|
# ============================================================================
|
|
export -f calculate_system_reserve
|
|
export -f calculate_max_children_memory_based
|
|
export -f calculate_peak_concurrent_requests_improved
|
|
export -f calculate_max_children_traffic_based
|
|
export -f detect_mysql_memory_usage
|
|
export -f recommend_pm_mode
|
|
export -f calculate_optimal_php_settings
|
|
export -f get_field
|