WordPress Performance Testing and Monitoring Tools
Performance testing isn't a one-time task—it's an ongoing process that ensures your WordPress site maintains optimal speed as it grows and evolves. This comprehensive guide covers essential testing tools, monitoring solutions, and automated performance tracking systems that help you identify bottlenecks, track improvements, and maintain consistent performance.
From free online tools to enterprise monitoring solutions, we'll explore how to effectively measure, analyze, and improve your WordPress site's performance. You'll learn not just which tools to use, but how to interpret their results and implement meaningful optimizations based on real data.
Table of Contents
- Performance Testing Fundamentals
- Popular Testing Tools
- Advanced Testing Techniques
- Real User Monitoring (RUM)
- Automated Performance Testing
- Custom Monitoring Solutions
- Performance Budgets and Reporting
Performance Testing Fundamentals
Key Performance Metrics
Understanding what to measure is crucial for effective performance testing:
// WordPress performance metrics tracker
class Performance_Metrics_Tracker {
private $metrics = [];
public function __construct() {
add_action('init', [$this, 'start_tracking']);
add_action('shutdown', [$this, 'collect_metrics']);
}
public function start_tracking() {
// Track request start time
$this->metrics['start_time'] = microtime(true);
$this->metrics['start_memory'] = memory_get_usage();
// Track database queries
if (defined('SAVEQUERIES') && SAVEQUERIES) {
$this->metrics['initial_queries'] = get_num_queries();
}
}
public function collect_metrics() {
// Calculate total execution time
$this->metrics['total_time'] = microtime(true) - $this->metrics['start_time'];
// Memory usage
$this->metrics['peak_memory'] = memory_get_peak_usage();
$this->metrics['end_memory'] = memory_get_usage();
$this->metrics['memory_used'] = $this->metrics['end_memory'] - $this->metrics['start_memory'];
// Database metrics
if (defined('SAVEQUERIES') && SAVEQUERIES) {
global $wpdb;
$this->metrics['total_queries'] = get_num_queries();
$this->metrics['slow_queries'] = $this->analyze_slow_queries($wpdb->queries);
$this->metrics['duplicate_queries'] = $this->find_duplicate_queries($wpdb->queries);
}
// Page size metrics
$this->metrics['html_size'] = ob_get_length();
// Store metrics for analysis
$this->store_metrics();
}
private function analyze_slow_queries($queries) {
$slow_queries = [];
$threshold = 0.05; // 50ms
foreach ($queries as $query) {
if ($query[1] > $threshold) {
$slow_queries[] = [
'sql' => $query[0],
'time' => $query[1],
'caller' => $query[2]
];
}
}
return $slow_queries;
}
private function find_duplicate_queries($queries) {
$query_counts = [];
foreach ($queries as $query) {
$sql = trim($query[0]);
if (!isset($query_counts[$sql])) {
$query_counts[$sql] = 0;
}
$query_counts[$sql]++;
}
return array_filter($query_counts, function($count) {
return $count > 1;
});
}
private function store_metrics() {
// Store in transient for dashboard display
set_transient('performance_metrics_' . get_current_user_id(), $this->metrics, HOUR_IN_SECONDS);
// Log to file if debugging
if (WP_DEBUG_LOG) {
error_log('Performance Metrics: ' . json_encode($this->metrics));
}
}
}
// Initialize tracker
if (defined('WP_DEBUG') && WP_DEBUG) {
new Performance_Metrics_Tracker();
}
Testing Methodology
// Standardized testing framework
class Performance_Test_Suite {
private $test_scenarios = [];
private $results = [];
public function add_scenario($name, $config) {
$this->test_scenarios[$name] = $config;
}
public function run_tests() {
foreach ($this->test_scenarios as $name => $config) {
$this->results[$name] = $this->execute_scenario($config);
}
return $this->generate_report();
}
private function execute_scenario($config) {
$results = [
'cold_cache' => [],
'warm_cache' => []
];
// Test with cold cache
$this->clear_all_caches();
$results['cold_cache'] = $this->perform_test($config);
// Test with warm cache
$results['warm_cache'] = $this->perform_test($config);
// Calculate statistics
$results['statistics'] = $this->calculate_statistics($results);
return $results;
}
private function perform_test($config) {
$iterations = $config['iterations'] ?? 3;
$url = $config['url'];
$measurements = [];
for ($i = 0; $i < $iterations; $i++) {
$start_time = microtime(true);
$response = wp_remote_get($url, [
'timeout' => 30,
'redirection' => 5,
'httpversion' => '1.1',
'user-agent' => $config['user_agent'] ?? 'WordPress Performance Tester',
'blocking' => true,
'headers' => $config['headers'] ?? [],
'cookies' => $config['cookies'] ?? []
]);
$end_time = microtime(true);
if (!is_wp_error($response)) {
$measurements[] = [
'response_time' => ($end_time - $start_time) * 1000, // ms
'http_code' => wp_remote_retrieve_response_code($response),
'body_size' => strlen(wp_remote_retrieve_body($response)),
'headers' => wp_remote_retrieve_headers($response),
'server_timing' => $this->parse_server_timing($response)
];
}
// Delay between tests
if ($i < $iterations - 1) {
sleep(1);
}
}
return $measurements;
}
private function parse_server_timing($response) {
$headers = wp_remote_retrieve_headers($response);
$server_timing = $headers['server-timing'] ?? '';
if (empty($server_timing)) {
return [];
}
$metrics = [];
$parts = explode(',', $server_timing);
foreach ($parts as $part) {
if (preg_match('/(\w+);dur=([\d.]+)/', trim($part), $matches)) {
$metrics[$matches[1]] = floatval($matches[2]);
}
}
return $metrics;
}
private function calculate_statistics($results) {
$all_times = [];
foreach (['cold_cache', 'warm_cache'] as $cache_state) {
$times = array_column($results[$cache_state], 'response_time');
if (!empty($times)) {
$all_times[$cache_state] = [
'min' => min($times),
'max' => max($times),
'avg' => array_sum($times) / count($times),
'median' => $this->calculate_median($times),
'p95' => $this->calculate_percentile($times, 95)
];
}
}
return $all_times;
}
private function calculate_median($values) {
sort($values);
$count = count($values);
if ($count % 2 == 0) {
return ($values[$count / 2 - 1] + $values[$count / 2]) / 2;
}
return $values[floor($count / 2)];
}
private function calculate_percentile($values, $percentile) {
sort($values);
$index = ceil(($percentile / 100) * count($values)) - 1;
return $values[$index];
}
private function clear_all_caches() {
// Clear object cache
wp_cache_flush();
// Clear page cache if available
if (function_exists('wp_cache_clear_cache')) {
wp_cache_clear_cache();
}
// Clear transients
global $wpdb;
$wpdb->query("DELETE FROM {$wpdb->options} WHERE option_name LIKE '_transient_%'");
// Trigger cache clear hooks
do_action('litespeed_purge_all');
do_action('rocket_clean_domain');
do_action('w3tc_flush_all');
}
}
Popular Testing Tools
Google PageSpeed Insights Integration
// PageSpeed Insights API integration
class PageSpeed_Insights_Tester {
private $api_key;
private $api_url = 'https://www.googleapis.com/pagespeedonline/v5/runPagespeed';
public function __construct($api_key) {
$this->api_key = $api_key;
}
public function test_url($url, $strategy = 'mobile') {
$params = [
'url' => $url,
'key' => $this->api_key,
'strategy' => $strategy,
'category' => ['performance', 'accessibility', 'best-practices', 'seo']
];
$response = wp_remote_get(add_query_arg($params, $this->api_url), [
'timeout' => 60
]);
if (is_wp_error($response)) {
return ['error' => $response->get_error_message()];
}
$body = wp_remote_retrieve_body($response);
$data = json_decode($body, true);
return $this->parse_results($data);
}
private function parse_results($data) {
if (!isset($data['lighthouseResult'])) {
return ['error' => 'Invalid response from PageSpeed Insights'];
}
$lighthouse = $data['lighthouseResult'];
return [
'scores' => [
'performance' => $lighthouse['categories']['performance']['score'] * 100,
'accessibility' => $lighthouse['categories']['accessibility']['score'] * 100,
'best_practices' => $lighthouse['categories']['best-practices']['score'] * 100,
'seo' => $lighthouse['categories']['seo']['score'] * 100
],
'metrics' => [
'fcp' => $lighthouse['audits']['first-contentful-paint']['numericValue'],
'lcp' => $lighthouse['audits']['largest-contentful-paint']['numericValue'],
'fid' => $lighthouse['audits']['max-potential-fid']['numericValue'],
'cls' => $lighthouse['audits']['cumulative-layout-shift']['numericValue'],
'ttfb' => $lighthouse['audits']['server-response-time']['numericValue'],
'tti' => $lighthouse['audits']['interactive']['numericValue'],
'tbt' => $lighthouse['audits']['total-blocking-time']['numericValue'],
'speed_index' => $lighthouse['audits']['speed-index']['numericValue']
],
'opportunities' => $this->extract_opportunities($lighthouse['audits']),
'diagnostics' => $this->extract_diagnostics($lighthouse['audits'])
];
}
private function extract_opportunities($audits) {
$opportunities = [];
$opportunity_audits = [
'render-blocking-resources',
'unused-css-rules',
'unused-javascript',
'modern-image-formats',
'uses-optimized-images',
'uses-text-compression',
'uses-responsive-images',
'efficient-animated-content'
];
foreach ($opportunity_audits as $audit_id) {
if (isset($audits[$audit_id]) && $audits[$audit_id]['score'] < 0.9) {
$opportunities[] = [
'id' => $audit_id,
'title' => $audits[$audit_id]['title'],
'description' => $audits[$audit_id]['description'],
'savings' => $audits[$audit_id]['details']['overallSavingsMs'] ?? 0,
'score' => $audits[$audit_id]['score']
];
}
}
// Sort by potential savings
usort($opportunities, function($a, $b) {
return $b['savings'] - $a['savings'];
});
return $opportunities;
}
private function extract_diagnostics($audits) {
$diagnostics = [];
$diagnostic_audits = [
'font-display',
'critical-request-chains',
'mainthread-work-breakdown',
'bootup-time',
'uses-rel-preconnect',
'server-response-time',
'redirects',
'uses-rel-preload'
];
foreach ($diagnostic_audits as $audit_id) {
if (isset($audits[$audit_id])) {
$diagnostics[$audit_id] = [
'title' => $audits[$audit_id]['title'],
'score' => $audits[$audit_id]['score'],
'displayValue' => $audits[$audit_id]['displayValue'] ?? '',
'details' => $audits[$audit_id]['details'] ?? []
];
}
}
return $diagnostics;
}
}
// Usage example
add_action('admin_menu', function() {
add_management_page(
'PageSpeed Test',
'PageSpeed Test',
'manage_options',
'pagespeed-test',
function() {
$tester = new PageSpeed_Insights_Tester(get_option('pagespeed_api_key'));
$results = $tester->test_url(home_url(), 'mobile');
// Display results
include plugin_dir_path(__FILE__) . 'views/pagespeed-results.php';
}
);
});
GTmetrix API Integration
// GTmetrix automated testing
class GTmetrix_Tester {
private $api_username;
private $api_key;
private $api_url = 'https://gtmetrix.com/api/2.0/';
public function __construct($username, $api_key) {
$this->api_username = $username;
$this->api_key = $api_key;
}
public function start_test($url, $options = []) {
$default_options = [
'location' => 'Vancouver, Canada',
'browser' => 'Chrome',
'report' => 'lighthouse',
'retention' => 1 // days
];
$options = wp_parse_args($options, $default_options);
$response = wp_remote_post($this->api_url . 'tests', [
'headers' => [
'Authorization' => 'Basic ' . base64_encode($this->api_username . ':' . $this->api_key),
'Content-Type' => 'application/vnd.api+json'
],
'body' => json_encode([
'data' => [
'type' => 'test',
'attributes' => array_merge(['url' => $url], $options)
]
])
]);
if (is_wp_error($response)) {
return ['error' => $response->get_error_message()];
}
$body = json_decode(wp_remote_retrieve_body($response), true);
if (isset($body['data']['id'])) {
return [
'test_id' => $body['data']['id'],
'status_url' => $body['links']['self']
];
}
return ['error' => 'Failed to start test'];
}
public function get_test_results($test_id) {
$response = wp_remote_get($this->api_url . 'tests/' . $test_id, [
'headers' => [
'Authorization' => 'Basic ' . base64_encode($this->api_username . ':' . $this->api_key)
]
]);
if (is_wp_error($response)) {
return ['error' => $response->get_error_message()];
}
$body = json_decode(wp_remote_retrieve_body($response), true);
if ($body['data']['attributes']['state'] === 'completed') {
return $this->parse_gtmetrix_results($body['data']);
}
return ['status' => $body['data']['attributes']['state']];
}
private function parse_gtmetrix_results($data) {
$attributes = $data['attributes'];
return [
'summary' => [
'gtmetrix_grade' => $attributes['gtmetrix_grade'],
'performance_score' => $attributes['performance_score'],
'structure_score' => $attributes['structure_score'],
'web_vitals' => [
'lcp' => $attributes['lcp_time'],
'fcp' => $attributes['fcp_time'],
'cls' => $attributes['cls_score'],
'tbt' => $attributes['tbt_time']
]
],
'timings' => [
'ttfb' => $attributes['ttfb'],
'first_paint' => $attributes['first_paint_time'],
'dom_interactive' => $attributes['dom_interactive_time'],
'onload' => $attributes['onload_time'],
'fully_loaded' => $attributes['fully_loaded_time']
],
'page_details' => [
'total_size' => $attributes['page_bytes'],
'total_requests' => $attributes['page_elements'],
'html_size' => $attributes['html_bytes'],
'css_size' => $attributes['css_bytes'],
'js_size' => $attributes['js_bytes'],
'image_size' => $attributes['image_bytes']
],
'report_url' => $attributes['report_url'],
'resources' => $data['links']
];
}
public function schedule_recurring_test($url, $frequency = 'daily') {
$hook = 'gtmetrix_scheduled_test_' . md5($url);
if (!wp_next_scheduled($hook)) {
wp_schedule_event(time(), $frequency, $hook, [$url]);
}
add_action($hook, function($test_url) {
$test = $this->start_test($test_url);
if (!isset($test['error'])) {
// Store test ID for later retrieval
$scheduled_tests = get_option('gtmetrix_scheduled_tests', []);
$scheduled_tests[] = [
'url' => $test_url,
'test_id' => $test['test_id'],
'started_at' => current_time('mysql')
];
update_option('gtmetrix_scheduled_tests', $scheduled_tests);
}
});
}
}
WebPageTest Integration
// WebPageTest API wrapper
class WebPageTest_Integration {
private $api_key;
private $api_url = 'https://www.webpagetest.org/';
public function __construct($api_key) {
$this->api_key = $api_key;
}
public function run_test($url, $options = []) {
$default_options = [
'location' => 'Dulles:Chrome',
'runs' => 3,
'fvonly' => 0, // Include repeat view
'video' => 1,
'lighthouse' => 1,
'k' => $this->api_key,
'f' => 'json'
];
$options = wp_parse_args($options, $default_options);
$options['url'] = $url;
$response = wp_remote_post($this->api_url . 'runtest.php', [
'body' => $options,
'timeout' => 30
]);
if (is_wp_error($response)) {
return ['error' => $response->get_error_message()];
}
$body = json_decode(wp_remote_retrieve_body($response), true);
if ($body['statusCode'] == 200) {
return [
'test_id' => $body['data']['testId'],
'status_url' => $body['data']['jsonUrl'],
'user_url' => $body['data']['userUrl']
];
}
return ['error' => $body['statusText'] ?? 'Unknown error'];
}
public function get_results($test_id) {
$response = wp_remote_get($this->api_url . 'jsonResult.php', [
'body' => [
'test' => $test_id
]
]);
if (is_wp_error($response)) {
return ['error' => $response->get_error_message()];
}
$body = json_decode(wp_remote_retrieve_body($response), true);
if ($body['statusCode'] == 200) {
return $this->parse_webpagetest_results($body['data']);
}
return ['status' => $body['statusText']];
}
private function parse_webpagetest_results($data) {
$first_view = $data['runs'][1]['firstView'];
$repeat_view = $data['runs'][1]['repeatView'] ?? null;
$results = [
'summary' => [
'url' => $data['url'],
'from' => $data['from'],
'connectivity' => $data['connectivity'],
'test_runs' => $data['runs']
],
'first_view' => [
'load_time' => $first_view['loadTime'],
'ttfb' => $first_view['TTFB'],
'start_render' => $first_view['render'],
'speed_index' => $first_view['SpeedIndex'],
'visually_complete' => $first_view['visualComplete'],
'fully_loaded' => $first_view['fullyLoaded'],
'requests' => $first_view['requests'],
'bytes_total' => $first_view['bytesIn'],
'domains' => $first_view['domains']
],
'web_vitals' => [
'lcp' => $first_view['chromeUserTiming.LargestContentfulPaint'],
'fid' => $first_view['chromeUserTiming.FirstInputDelay'],
'cls' => $first_view['chromeUserTiming.CumulativeLayoutShift'],
'fcp' => $first_view['firstContentfulPaint'],
'ttfb' => $first_view['TTFB']
],
'optimization_scores' => [
'keep_alive' => $first_view['score_keep-alive'],
'gzip' => $first_view['score_gzip'],
'image_compression' => $first_view['score_compress'],
'caching' => $first_view['score_cache'],
'cdn' => $first_view['score_cdn']
]
];
if ($repeat_view) {
$results['repeat_view'] = [
'load_time' => $repeat_view['loadTime'],
'ttfb' => $repeat_view['TTFB'],
'start_render' => $repeat_view['render'],
'fully_loaded' => $repeat_view['fullyLoaded'],
'cached_requests' => $first_view['requests'] - $repeat_view['requests']
];
}
// Add video and filmstrip if available
if (isset($first_view['videoFrames'])) {
$results['filmstrip'] = $this->generate_filmstrip_data($first_view['videoFrames']);
}
return $results;
}
private function generate_filmstrip_data($frames) {
$filmstrip = [];
foreach ($frames as $frame) {
$filmstrip[] = [
'time' => $frame['time'],
'image' => $frame['image'],
'visual_progress' => $frame['VisuallyComplete']
];
}
return $filmstrip;
}
}
Advanced Testing Techniques
Synthetic Monitoring
// Synthetic monitoring implementation
class Synthetic_Monitor {
private $monitors = [];
private $alert_thresholds = [];
public function add_monitor($name, $config) {
$this->monitors[$name] = array_merge([
'url' => '',
'frequency' => 300, // 5 minutes
'locations' => ['us-east-1'],
'assertions' => [],
'notifications' => []
], $config);
$this->schedule_monitor($name);
}
private function schedule_monitor($name) {
$hook = 'synthetic_monitor_' . $name;
$monitor = $this->monitors[$name];
if (!wp_next_scheduled($hook)) {
wp_schedule_event(time(), 'every_five_minutes', $hook);
}
add_action($hook, function() use ($name, $monitor) {
$this->run_monitor($name, $monitor);
});
}
private function run_monitor($name, $config) {
$results = [];
foreach ($config['locations'] as $location) {
$result = $this->test_from_location($config['url'], $location);
$results[$location] = $result;
// Check assertions
$failures = $this->check_assertions($result, $config['assertions']);
if (!empty($failures)) {
$this->handle_failures($name, $location, $failures, $config['notifications']);
}
}
// Store results
$this->store_monitor_results($name, $results);
}
private function test_from_location($url, $location) {
// Simulate testing from different locations
$start_time = microtime(true);
$response = wp_remote_get($url, [
'timeout' => 30,
'headers' => [
'X-Test-Location' => $location
]
]);
$end_time = microtime(true);
if (is_wp_error($response)) {
return [
'success' => false,
'error' => $response->get_error_message(),
'response_time' => ($end_time - $start_time) * 1000
];
}
return [
'success' => true,
'response_time' => ($end_time - $start_time) * 1000,
'status_code' => wp_remote_retrieve_response_code($response),
'body_size' => strlen(wp_remote_retrieve_body($response)),
'headers' => wp_remote_retrieve_headers($response)
];
}
private function check_assertions($result, $assertions) {
$failures = [];
foreach ($assertions as $assertion) {
switch ($assertion['type']) {
case 'response_time':
if ($result['response_time'] > $assertion['value']) {
$failures[] = sprintf(
'Response time %dms exceeds threshold %dms',
$result['response_time'],
$assertion['value']
);
}
break;
case 'status_code':
if ($result['status_code'] != $assertion['value']) {
$failures[] = sprintf(
'Status code %d does not match expected %d',
$result['status_code'],
$assertion['value']
);
}
break;
case 'content_contains':
$body = wp_remote_retrieve_body($result['response']);
if (strpos($body, $assertion['value']) === false) {
$failures[] = sprintf(
'Response does not contain expected text: %s',
$assertion['value']
);
}
break;
}
}
return $failures;
}
private function handle_failures($monitor_name, $location, $failures, $notifications) {
$message = sprintf(
"Monitor '%s' failed from %s:\n%s",
$monitor_name,
$location,
implode("\n", $failures)
);
// Log failure
error_log($message);
// Send notifications
foreach ($notifications as $notification) {
switch ($notification['type']) {
case 'email':
wp_mail(
$notification['address'],
'Monitor Alert: ' . $monitor_name,
$message
);
break;
case 'slack':
$this->send_slack_notification($notification['webhook'], $message);
break;
case 'webhook':
wp_remote_post($notification['url'], [
'body' => json_encode([
'monitor' => $monitor_name,
'location' => $location,
'failures' => $failures,
'timestamp' => current_time('c')
])
]);
break;
}
}
}
private function store_monitor_results($name, $results) {
global $wpdb;
$table_name = $wpdb->prefix . 'synthetic_monitor_results';
foreach ($results as $location => $result) {
$wpdb->insert($table_name, [
'monitor_name' => $name,
'location' => $location,
'success' => $result['success'] ? 1 : 0,
'response_time' => $result['response_time'],
'status_code' => $result['status_code'] ?? null,
'error_message' => $result['error'] ?? null,
'tested_at' => current_time('mysql')
]);
}
// Clean old results (keep 30 days)
$wpdb->query($wpdb->prepare(
"DELETE FROM $table_name WHERE tested_at < DATE_SUB(NOW(), INTERVAL 30 DAY)"
));
}
}
Load Testing
// WordPress load testing framework
class Load_Testing_Framework {
private $scenarios = [];
private $results = [];
public function create_scenario($name, $config) {
$this->scenarios[$name] = array_merge([
'users' => 10,
'ramp_up' => 60, // seconds
'duration' => 300, // seconds
'think_time' => 5, // seconds between requests
'pages' => []
], $config);
}
public function run_load_test($scenario_name) {
if (!isset($this->scenarios[$scenario_name])) {
return ['error' => 'Scenario not found'];
}
$scenario = $this->scenarios[$scenario_name];
// Initialize results
$this->results[$scenario_name] = [
'start_time' => time(),
'requests' => [],
'errors' => [],
'response_times' => []
];
// Simulate virtual users
$this->simulate_users($scenario);
// Calculate statistics
return $this->calculate_load_test_results($scenario_name);
}
private function simulate_users($scenario) {
$total_users = $scenario['users'];
$ramp_up_delay = $scenario['ramp_up'] / $total_users;
for ($user = 0; $user < $total_users; $user++) {
// Stagger user start times
sleep($ramp_up_delay);
// Run user simulation in background
wp_schedule_single_event(time(), 'load_test_user_' . $user, [$scenario]);
}
// Wait for test duration
sleep($scenario['duration']);
}
private function simulate_user_behavior($scenario) {
$end_time = time() + $scenario['duration'];
while (time() < $end_time) {
// Random page from scenario
$page = $scenario['pages'][array_rand($scenario['pages'])];
// Make request
$start = microtime(true);
$response = wp_remote_get($page['url'], [
'timeout' => 30,
'cookies' => $page['cookies'] ?? []
]);
$duration = (microtime(true) - $start) * 1000;
// Record result
$this->record_request_result($page['url'], $response, $duration);
// Think time
sleep($scenario['think_time'] + rand(-2, 2));
}
}
private function record_request_result($url, $response, $duration) {
$result = [
'url' => $url,
'timestamp' => microtime(true),
'duration' => $duration,
'success' => !is_wp_error($response),
'status_code' => is_wp_error($response) ? 0 : wp_remote_retrieve_response_code($response),
'size' => is_wp_error($response) ? 0 : strlen(wp_remote_retrieve_body($response))
];
// Thread-safe storage
$transient_key = 'load_test_results_' . md5($url . microtime());
set_transient($transient_key, $result, HOUR_IN_SECONDS);
}
private function calculate_load_test_results($scenario_name) {
// Collect all results from transients
global $wpdb;
$results = $wpdb->get_results(
"SELECT option_value FROM {$wpdb->options}
WHERE option_name LIKE '_transient_load_test_results_%'"
);
$all_requests = [];
foreach ($results as $result) {
$all_requests[] = maybe_unserialize($result->option_value);
}
// Calculate statistics
$response_times = array_column($all_requests, 'duration');
$success_count = count(array_filter($all_requests, function($r) {
return $r['success'];
}));
return [
'total_requests' => count($all_requests),
'successful_requests' => $success_count,
'failed_requests' => count($all_requests) - $success_count,
'error_rate' => (count($all_requests) - $success_count) / count($all_requests) * 100,
'response_times' => [
'min' => min($response_times),
'max' => max($response_times),
'avg' => array_sum($response_times) / count($response_times),
'median' => $this->calculate_median($response_times),
'p95' => $this->calculate_percentile($response_times, 95),
'p99' => $this->calculate_percentile($response_times, 99)
],
'throughput' => count($all_requests) / $this->scenarios[$scenario_name]['duration'],
'bandwidth' => array_sum(array_column($all_requests, 'size')) / 1024 / 1024 // MB
];
}
}
Real User Monitoring (RUM)
RUM Implementation
// Real User Monitoring script
(function() {
const RUM = {
data: {
navigation: {},
resources: [],
errors: [],
userInteractions: []
},
init: function() {
// Navigation timing
if (window.performance && window.performance.timing) {
this.collectNavigationTiming();
}
// Resource timing
if (window.performance && window.performance.getEntriesByType) {
this.collectResourceTiming();
}
// Core Web Vitals
this.observeWebVitals();
// Error tracking
this.trackErrors();
// User interactions
this.trackInteractions();
// Send data before unload
window.addEventListener('beforeunload', () => this.sendData());
},
collectNavigationTiming: function() {
const timing = window.performance.timing;
const navigation = window.performance.navigation;
this.data.navigation = {
// Network
dns: timing.domainLookupEnd - timing.domainLookupStart,
tcp: timing.connectEnd - timing.connectStart,
ttfb: timing.responseStart - timing.navigationStart,
// Document processing
domProcessing: timing.domComplete - timing.domLoading,
domInteractive: timing.domInteractive - timing.navigationStart,
domContentLoaded: timing.domContentLoadedEventEnd - timing.navigationStart,
// Full page load
loadComplete: timing.loadEventEnd - timing.navigationStart,
// Navigation type
type: ['navigate', 'reload', 'back_forward'][navigation.type] || 'unknown',
redirectCount: navigation.redirectCount
};
},
collectResourceTiming: function() {
const resources = window.performance.getEntriesByType('resource');
this.data.resources = resources.map(resource => ({
name: resource.name,
type: this.getResourceType(resource.name),
duration: resource.duration,
size: resource.transferSize || 0,
protocol: resource.nextHopProtocol,
cached: resource.transferSize === 0 && resource.decodedBodySize > 0
}));
// Group by type
this.data.resourceSummary = this.summarizeResources(this.data.resources);
},
getResourceType: function(url) {
const extension = url.split('.').pop().split('?')[0].toLowerCase();
const typeMap = {
'js': 'script',
'css': 'stylesheet',
'jpg': 'image',
'jpeg': 'image',
'png': 'image',
'gif': 'image',
'webp': 'image',
'svg': 'image',
'woff': 'font',
'woff2': 'font',
'ttf': 'font',
'eot': 'font'
};
return typeMap[extension] || 'other';
},
summarizeResources: function(resources) {
const summary = {};
resources.forEach(resource => {
if (!summary[resource.type]) {
summary[resource.type] = {
count: 0,
totalSize: 0,
totalDuration: 0,
cached: 0
};
}
summary[resource.type].count++;
summary[resource.type].totalSize += resource.size;
summary[resource.type].totalDuration += resource.duration;
if (resource.cached) summary[resource.type].cached++;
});
return summary;
},
observeWebVitals: function() {
// Largest Contentful Paint
new PerformanceObserver((list) => {
const entries = list.getEntries();
const lastEntry = entries[entries.length - 1];
this.data.lcp = lastEntry.renderTime || lastEntry.loadTime;
}).observe({ entryTypes: ['largest-contentful-paint'] });
// First Input Delay
new PerformanceObserver((list) => {
const firstInput = list.getEntries()[0];
this.data.fid = firstInput.processingStart - firstInput.startTime;
}).observe({ entryTypes: ['first-input'] });
// Cumulative Layout Shift
let clsValue = 0;
new PerformanceObserver((list) => {
for (const entry of list.getEntries()) {
if (!entry.hadRecentInput) {
clsValue += entry.value;
}
}
this.data.cls = clsValue;
}).observe({ entryTypes: ['layout-shift'] });
},
trackErrors: function() {
window.addEventListener('error', (event) => {
this.data.errors.push({
message: event.message,
source: event.filename,
line: event.lineno,
column: event.colno,
timestamp: Date.now()
});
});
},
trackInteractions: function() {
// Track slow clicks
document.addEventListener('click', (event) => {
const startTime = Date.now();
setTimeout(() => {
const duration = Date.now() - startTime;
if (duration > 100) {
this.data.userInteractions.push({
type: 'slow_click',
target: event.target.tagName,
duration: duration,
timestamp: startTime
});
}
}, 0);
});
},
sendData: function() {
// Add session info
this.data.session = {
url: window.location.href,
referrer: document.referrer,
userAgent: navigator.userAgent,
viewport: {
width: window.innerWidth,
height: window.innerHeight
},
connection: navigator.connection ? {
effectiveType: navigator.connection.effectiveType,
downlink: navigator.connection.downlink,
rtt: navigator.connection.rtt
} : null
};
// Send to analytics endpoint
if (navigator.sendBeacon) {
navigator.sendBeacon('/wp-json/performance/v1/rum', JSON.stringify(this.data));
} else {
fetch('/wp-json/performance/v1/rum', {
method: 'POST',
body: JSON.stringify(this.data),
keepalive: true
});
}
}
};
// Initialize when ready
if (document.readyState === 'complete') {
RUM.init();
} else {
window.addEventListener('load', () => RUM.init());
}
})();
RUM Data Processing
// Process RUM data on server
class RUM_Data_Processor {
public function __construct() {
add_action('rest_api_init', [$this, 'register_endpoints']);
add_action('rum_process_batch', [$this, 'process_batch']);
}
public function register_endpoints() {
register_rest_route('performance/v1', '/rum', [
'methods' => 'POST',
'callback' => [$this, 'receive_rum_data'],
'permission_callback' => '__return_true'
]);
}
public function receive_rum_data($request) {
$data = $request->get_json_params();
// Validate data
if (!$this->validate_rum_data($data)) {
return new WP_Error('invalid_data', 'Invalid RUM data', ['status' => 400]);
}
// Store in queue for batch processing
$queue_item = [
'data' => $data,
'received_at' => current_time('mysql'),
'ip' => $_SERVER['REMOTE_ADDR'],
'processed' => false
];
$this->add_to_queue($queue_item);
// Schedule batch processing
if (!wp_next_scheduled('rum_process_batch')) {
wp_schedule_event(time(), 'every_five_minutes', 'rum_process_batch');
}
return ['success' => true];
}
private function validate_rum_data($data) {
$required_fields = ['navigation', 'session'];
foreach ($required_fields as $field) {
if (!isset($data[$field])) {
return false;
}
}
return true;
}
private function add_to_queue($item) {
global $wpdb;
$table_name = $wpdb->prefix . 'rum_queue';
$wpdb->insert($table_name, [
'data' => json_encode($item['data']),
'received_at' => $item['received_at'],
'ip_address' => $item['ip'],
'processed' => 0
]);
}
public function process_batch() {
global $wpdb;
$table_name = $wpdb->prefix . 'rum_queue';
// Get unprocessed items
$items = $wpdb->get_results(
"SELECT * FROM $table_name WHERE processed = 0 LIMIT 100"
);
foreach ($items as $item) {
$data = json_decode($item->data, true);
// Process metrics
$this->process_navigation_metrics($data['navigation']);
$this->process_resource_metrics($data['resources']);
$this->process_web_vitals($data);
// Mark as processed
$wpdb->update($table_name, ['processed' => 1], ['id' => $item->id]);
}
// Clean old processed items
$wpdb->query(
"DELETE FROM $table_name
WHERE processed = 1 AND received_at < DATE_SUB(NOW(), INTERVAL 7 DAY)"
);
}
private function process_navigation_metrics($navigation) {
// Store aggregated metrics
$metrics = [
'ttfb' => $navigation['ttfb'],
'dom_ready' => $navigation['domContentLoaded'],
'load_complete' => $navigation['loadComplete']
];
foreach ($metrics as $metric => $value) {
$this->update_metric_statistics($metric, $value);
}
}
private function update_metric_statistics($metric, $value) {
$stats = get_option("rum_stats_{$metric}", [
'count' => 0,
'sum' => 0,
'min' => PHP_INT_MAX,
'max' => 0,
'values' => []
]);
$stats['count']++;
$stats['sum'] += $value;
$stats['min'] = min($stats['min'], $value);
$stats['max'] = max($stats['max'], $value);
// Keep last 1000 values for percentile calculation
$stats['values'][] = $value;
if (count($stats['values']) > 1000) {
array_shift($stats['values']);
}
update_option("rum_stats_{$metric}", $stats);
}
}
new RUM_Data_Processor();
Automated Performance Testing
CI/CD Integration
# GitHub Actions workflow for performance testing
name: Performance Testing
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]
schedule:
- cron: '0 */6 * * *' # Every 6 hours
jobs:
lighthouse:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Setup Node.js
uses: actions/setup-node@v2
with:
node-version: '16'
- name: Install Lighthouse CI
run: npm install -g @lhci/cli
- name: Run Lighthouse tests
run: |
lhci autorun \
--collect.url=${{ secrets.SITE_URL }} \
--collect.numberOfRuns=3 \
--upload.target=temporary-public-storage
- name: Check performance budget
run: |
lhci assert \
--preset=lighthouse:recommended \
--assertions.categories:performance=0.9 \
--assertions.first-contentful-paint=2000 \
--assertions.largest-contentful-paint=2500 \
--assertions.cumulative-layout-shift=0.1
- name: Upload results
uses: actions/upload-artifact@v2
with:
name: lighthouse-results
path: .lighthouseci
load-test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Run k6 load test
run: |
docker run --rm \
-v $PWD:/scripts \
loadimpact/k6 run \
--vus 50 \
--duration 5m \
/scripts/tests/load-test.js
- name: Analyze results
run: |
# Check if 95th percentile response time is under 1s
if [ $(jq '.metrics.http_req_duration["p(95)"]' summary.json) -gt 1000 ]; then
echo "Performance regression detected!"
exit 1
fi
Performance Regression Detection
// Automated performance regression detection
class Performance_Regression_Detector {
private $baseline_metrics = [];
private $threshold_percentage = 10; // 10% degradation threshold
public function __construct() {
$this->load_baseline_metrics();
add_action('performance_test_complete', [$this, 'check_for_regressions']);
}
private function load_baseline_metrics() {
$this->baseline_metrics = get_option('performance_baseline_metrics', [
'ttfb' => 200,
'fcp' => 1500,
'lcp' => 2500,
'fid' => 100,
'cls' => 0.1,
'page_weight' => 2048000, // 2MB
'requests' => 50
]);
}
public function check_for_regressions($test_results) {
$regressions = [];
foreach ($this->baseline_metrics as $metric => $baseline) {
if (!isset($test_results[$metric])) {
continue;
}
$current = $test_results[$metric];
$change_percentage = (($current - $baseline) / $baseline) * 100;
if ($change_percentage > $this->threshold_percentage) {
$regressions[] = [
'metric' => $metric,
'baseline' => $baseline,
'current' => $current,
'degradation' => round($change_percentage, 2) . '%'
];
}
}
if (!empty($regressions)) {
$this->handle_regressions($regressions);
}
return $regressions;
}
private function handle_regressions($regressions) {
// Create detailed report
$report = $this->generate_regression_report($regressions);
// Send notifications
$this->notify_team($report);
// Create GitHub issue if configured
if (get_option('create_github_issues_for_regressions')) {
$this->create_github_issue($report);
}
// Block deployment if critical
if ($this->has_critical_regression($regressions)) {
wp_die('Critical performance regression detected. Deployment blocked.');
}
}
private function generate_regression_report($regressions) {
$report = "## Performance Regression Detected\n\n";
$report .= "The following metrics have degraded beyond acceptable thresholds:\n\n";
foreach ($regressions as $regression) {
$report .= sprintf(
"- **%s**: %s → %s (↓ %s)\n",
$this->get_metric_name($regression['metric']),
$this->format_metric_value($regression['metric'], $regression['baseline']),
$this->format_metric_value($regression['metric'], $regression['current']),
$regression['degradation']
);
}
$report .= "\n### Recommendations\n\n";
$report .= $this->generate_recommendations($regressions);
return $report;
}
private function generate_recommendations($regressions) {
$recommendations = [];
foreach ($regressions as $regression) {
switch ($regression['metric']) {
case 'ttfb':
$recommendations[] = '- Check server response time and database queries';
$recommendations[] = '- Review recent plugin additions';
break;
case 'lcp':
$recommendations[] = '- Optimize largest content element';
$recommendations[] = '- Check image loading performance';
break;
case 'page_weight':
$recommendations[] = '- Review recently added assets';
$recommendations[] = '- Check for unoptimized images';
break;
}
}
return implode("\n", array_unique($recommendations));
}
private function create_github_issue($report) {
$github_api = new GitHub_API(get_option('github_token'));
$issue = [
'title' => 'Performance Regression Detected - ' . date('Y-m-d'),
'body' => $report,
'labels' => ['performance', 'regression', 'automated']
];
$github_api->create_issue(
get_option('github_repo'),
$issue
);
}
}
Custom Monitoring Solutions
Custom Performance Dashboard
// WordPress performance dashboard
class Performance_Dashboard {
public function __construct() {
add_action('wp_dashboard_setup', [$this, 'add_dashboard_widgets']);
add_action('admin_enqueue_scripts', [$this, 'enqueue_dashboard_scripts']);
}
public function add_dashboard_widgets() {
wp_add_dashboard_widget(
'performance_overview',
'Performance Overview',
[$this, 'render_performance_overview']
);
wp_add_dashboard_widget(
'performance_trends',
'Performance Trends',
[$this, 'render_performance_trends']
);
}
public function render_performance_overview() {
$current_metrics = $this->get_current_metrics();
?>
<div class="performance-metrics">
<div class="metric-grid">
<?php foreach ($current_metrics as $metric => $data): ?>
<div class="metric-card">
<h4><?php echo esc_html($data['label']); ?></h4>
<div class="metric-value <?php echo esc_attr($data['status']); ?>">
<?php echo esc_html($data['value']); ?>
</div>
<div class="metric-target">
Target: <?php echo esc_html($data['target']); ?>
</div>
</div>
<?php endforeach; ?>
</div>
</div>
<?php
}
public function render_performance_trends() {
?>
<div id="performance-chart" style="height: 300px;"></div>
<script>
jQuery(document).ready(function($) {
const chartData = <?php echo json_encode($this->get_trend_data()); ?>;
// Render chart using Chart.js
const ctx = document.getElementById('performance-chart').getContext('2d');
new Chart(ctx, {
type: 'line',
data: {
labels: chartData.labels,
datasets: [{
label: 'Page Load Time',
data: chartData.loadTime,
borderColor: '#0073aa',
tension: 0.1
}, {
label: 'TTFB',
data: chartData.ttfb,
borderColor: '#00a0d2',
tension: 0.1
}]
},
options: {
responsive: true,
maintainAspectRatio: false,
scales: {
y: {
beginAtZero: true,
title: {
display: true,
text: 'Time (ms)'
}
}
}
}
});
});
</script>
<?php
}
private function get_current_metrics() {
// Fetch latest performance data
$latest_test = $this->get_latest_test_results();
return [
'load_time' => [
'label' => 'Page Load Time',
'value' => $latest_test['load_time'] . 'ms',
'target' => '< 3000ms',
'status' => $latest_test['load_time'] < 3000 ? 'good' : 'warning'
],
'ttfb' => [
'label' => 'Time to First Byte',
'value' => $latest_test['ttfb'] . 'ms',
'target' => '< 200ms',
'status' => $latest_test['ttfb'] < 200 ? 'good' : 'warning'
],
'page_size' => [
'label' => 'Page Size',
'value' => $this->format_bytes($latest_test['page_size']),
'target' => '< 2MB',
'status' => $latest_test['page_size'] < 2097152 ? 'good' : 'warning'
],
'requests' => [
'label' => 'HTTP Requests',
'value' => $latest_test['requests'],
'target' => '< 50',
'status' => $latest_test['requests'] < 50 ? 'good' : 'warning'
]
];
}
private function get_trend_data($days = 7) {
global $wpdb;
$results = $wpdb->get_results($wpdb->prepare(
"SELECT DATE(tested_at) as date,
AVG(load_time) as avg_load_time,
AVG(ttfb) as avg_ttfb
FROM {$wpdb->prefix}performance_tests
WHERE tested_at > DATE_SUB(NOW(), INTERVAL %d DAY)
GROUP BY DATE(tested_at)
ORDER BY date ASC",
$days
));
$data = [
'labels' => [],
'loadTime' => [],
'ttfb' => []
];
foreach ($results as $result) {
$data['labels'][] = $result->date;
$data['loadTime'][] = round($result->avg_load_time);
$data['ttfb'][] = round($result->avg_ttfb);
}
return $data;
}
}
new Performance_Dashboard();
Performance Budgets and Reporting
Performance Budget Implementation
// Performance budget manager
class Performance_Budget_Manager {
private $budgets = [];
public function __construct() {
$this->load_budgets();
add_action('performance_test_complete', [$this, 'check_budgets']);
}
private function load_budgets() {
$this->budgets = get_option('performance_budgets', [
'metrics' => [
'lcp' => ['max' => 2500, 'unit' => 'ms'],
'fid' => ['max' => 100, 'unit' => 'ms'],
'cls' => ['max' => 0.1, 'unit' => 'score'],
'ttfb' => ['max' => 200, 'unit' => 'ms']
],
'resources' => [
'total_size' => ['max' => 2097152, 'unit' => 'bytes'], // 2MB
'javascript' => ['max' => 524288, 'unit' => 'bytes'], // 500KB
'css' => ['max' => 102400, 'unit' => 'bytes'], // 100KB
'images' => ['max' => 1048576, 'unit' => 'bytes'], // 1MB
'fonts' => ['max' => 204800, 'unit' => 'bytes'] // 200KB
],
'counts' => [
'requests' => ['max' => 50],
'domains' => ['max' => 10],
'javascript_files' => ['max' => 10],
'css_files' => ['max' => 5]
]
]);
}
public function check_budgets($test_results) {
$violations = [];
// Check metric budgets
foreach ($this->budgets['metrics'] as $metric => $budget) {
if (isset($test_results['metrics'][$metric])) {
$value = $test_results['metrics'][$metric];
if ($value > $budget['max']) {
$violations[] = [
'type' => 'metric',
'name' => $metric,
'value' => $value,
'budget' => $budget['max'],
'unit' => $budget['unit'],
'exceeded_by' => round((($value - $budget['max']) / $budget['max']) * 100, 2)
];
}
}
}
// Check resource budgets
foreach ($this->budgets['resources'] as $resource => $budget) {
if (isset($test_results['resources'][$resource])) {
$value = $test_results['resources'][$resource];
if ($value > $budget['max']) {
$violations[] = [
'type' => 'resource',
'name' => $resource,
'value' => $value,
'budget' => $budget['max'],
'unit' => $budget['unit'],
'exceeded_by' => round((($value - $budget['max']) / $budget['max']) * 100, 2)
];
}
}
}
if (!empty($violations)) {
$this->handle_budget_violations($violations);
}
return $violations;
}
private function handle_budget_violations($violations) {
// Log violations
error_log('Performance budget violations: ' . json_encode($violations));
// Send notifications
$this->send_violation_notifications($violations);
// Update status
update_option('performance_budget_status', [
'passing' => false,
'violations' => $violations,
'last_check' => current_time('mysql')
]);
// Trigger webhook if configured
$webhook_url = get_option('performance_budget_webhook');
if ($webhook_url) {
wp_remote_post($webhook_url, [
'body' => json_encode([
'event' => 'budget_violation',
'violations' => $violations,
'timestamp' => current_time('c')
])
]);
}
}
private function send_violation_notifications($violations) {
$message = "Performance Budget Violations Detected:\n\n";
foreach ($violations as $violation) {
$message .= sprintf(
"- %s: %s %s (budget: %s %s, exceeded by %s%%)\n",
ucfirst($violation['type']),
$violation['name'],
$this->format_value($violation['value'], $violation['unit']),
$this->format_value($violation['budget'], $violation['unit']),
$violation['unit'],
$violation['exceeded_by']
);
}
// Email notification
wp_mail(
get_option('admin_email'),
'Performance Budget Violation Alert',
$message
);
}
private function format_value($value, $unit) {
switch ($unit) {
case 'bytes':
return $this->format_bytes($value);
case 'ms':
return round($value) . 'ms';
case 'score':
return round($value, 2);
default:
return $value;
}
}
private function format_bytes($bytes) {
$units = ['B', 'KB', 'MB', 'GB'];
$unit = 0;
while ($bytes >= 1024 && $unit < count($units) - 1) {
$bytes /= 1024;
$unit++;
}
return round($bytes, 2) . ' ' . $units[$unit];
}
}
new Performance_Budget_Manager();
Automated Reporting
// Performance report generator
class Performance_Report_Generator {
public function generate_weekly_report() {
$report_data = $this->collect_report_data();
$html_report = $this->render_html_report($report_data);
// Send email report
$this->send_email_report($html_report);
// Generate PDF if configured
if (get_option('generate_pdf_reports')) {
$this->generate_pdf_report($html_report);
}
// Store report
$this->store_report($report_data);
}
private function collect_report_data() {
return [
'period' => [
'start' => date('Y-m-d', strtotime('-7 days')),
'end' => date('Y-m-d')
],
'summary' => $this->get_summary_statistics(),
'trends' => $this->analyze_trends(),
'incidents' => $this->get_performance_incidents(),
'improvements' => $this->identify_improvements(),
'recommendations' => $this->generate_recommendations()
];
}
private function render_html_report($data) {
ob_start();
?>
<!DOCTYPE html>
<html>
<head>
<title>Weekly Performance Report</title>
<style>
body { font-family: Arial, sans-serif; line-height: 1.6; }
.metric { display: inline-block; margin: 10px; padding: 15px; border: 1px solid #ddd; }
.good { color: green; }
.warning { color: orange; }
.error { color: red; }
table { width: 100%; border-collapse: collapse; }
th, td { padding: 10px; border: 1px solid #ddd; text-align: left; }
</style>
</head>
<body>
<h1>Weekly Performance Report</h1>
<p>Period: <?php echo $data['period']['start']; ?> to <?php echo $data['period']['end']; ?></p>
<h2>Summary</h2>
<div class="metrics">
<?php foreach ($data['summary'] as $metric => $value): ?>
<div class="metric">
<h3><?php echo $metric; ?></h3>
<p class="<?php echo $value['status']; ?>">
<?php echo $value['value']; ?>
</p>
</div>
<?php endforeach; ?>
</div>
<h2>Performance Trends</h2>
<img src="<?php echo $this->generate_trend_chart($data['trends']); ?>" alt="Performance Trends">
<h2>Incidents</h2>
<?php if (empty($data['incidents'])): ?>
<p>No performance incidents this week!</p>
<?php else: ?>
<table>
<tr>
<th>Date</th>
<th>Type</th>
<th>Description</th>
<th>Duration</th>
</tr>
<?php foreach ($data['incidents'] as $incident): ?>
<tr>
<td><?php echo $incident['date']; ?></td>
<td><?php echo $incident['type']; ?></td>
<td><?php echo $incident['description']; ?></td>
<td><?php echo $incident['duration']; ?></td>
</tr>
<?php endforeach; ?>
</table>
<?php endif; ?>
<h2>Recommendations</h2>
<ul>
<?php foreach ($data['recommendations'] as $recommendation): ?>
<li><?php echo $recommendation; ?></li>
<?php endforeach; ?>
</ul>
</body>
</html>
<?php
return ob_get_clean();
}
}
Next Steps
With comprehensive performance testing and monitoring in place:
- Set Performance Budgets: Define clear performance goals and enforce them
- Automate Testing: Integrate performance tests into your CI/CD pipeline
- Monitor Real Users: Implement RUM to understand actual user experience
- Regular Reviews: Schedule weekly performance reviews and optimizations
For more optimization strategies, explore our complete WordPress Performance Optimization guide.
Last updated: July 12, 2025