diff --git a/docs/MONITORING-SYSTEMS.md b/docs/MONITORING-SYSTEMS.md
new file mode 100644
index 00000000..96f2cab4
--- /dev/null
+++ b/docs/MONITORING-SYSTEMS.md
@@ -0,0 +1,412 @@
+# HVAC Plugin Monitoring Systems
+
+This document describes the comprehensive enterprise-level monitoring and reliability systems implemented in the HVAC Community Events plugin.
+
+## Overview
+
+The plugin includes four integrated monitoring systems:
+
+1. **Health Monitor** - Automated health checks and system validation
+2. **Error Recovery** - Automatic error recovery and graceful degradation
+3. **Security Monitor** - Real-time threat detection and response
+4. **Performance Monitor** - Performance tracking and optimization alerts
+
+## Health Monitor
+
+### Features
+- 8 different health check types
+- Automated hourly checks with email alerts
+- Admin dashboard integration
+- REST API endpoints for external monitoring
+- WP-CLI integration
+
+### Health Check Types
+- **Database Connectivity** - Tests database connection and table integrity
+- **Cache System** - Validates WordPress object cache functionality
+- **User Authentication** - Verifies role system and user capabilities
+- **Event Management** - Checks The Events Calendar integration
+- **Certificate System** - Validates certificate page existence and permissions
+- **Background Jobs** - Monitors background job queue health
+- **File Permissions** - Checks critical directory permissions
+- **Third Party Integrations** - Validates external plugin dependencies
+
+### Usage
+
+#### Admin Interface
+Navigate to `Tools > HVAC Health` to view comprehensive health status.
+
+#### WP-CLI
+```bash
+wp hvac health
+```
+
+#### REST API
+```
+GET /wp-json/hvac/v1/health
+```
+
+### Configuration
+Health checks run automatically every hour. Critical issues trigger immediate email alerts to the admin email address.
+
+## Error Recovery System
+
+### Features
+- 4 recovery strategies for different failure scenarios
+- Circuit breaker pattern for external services
+- Emergency mode activation for critical failures
+- Comprehensive error tracking and statistics
+
+### Recovery Strategies
+
+#### 1. Retry with Exponential Backoff
+Used for: Database queries, temporary failures
+- Max attempts: 3
+- Backoff multiplier: 2
+
+#### 2. Fallback Operations
+Used for: Cache operations, non-critical services
+- Falls back to safe alternatives
+- Skips functionality gracefully
+
+#### 3. Circuit Breaker
+Used for: External APIs, third-party services
+- Opens after 5 failures
+- 5-minute timeout period
+- Uses cached data when available
+
+#### 4. Graceful Failure
+Used for: File operations, optional features
+- Logs errors and continues operation
+- Returns safe default values
+
+### Usage
+
+#### Programmatic Usage
+```php
+$result = HVAC_Error_Recovery::execute_with_recovery(
+ 'database_query',
+ function() {
+ // Your database operation
+ return $wpdb->get_results("SELECT * FROM table");
+ }
+);
+```
+
+#### Admin Interface
+Navigate to `Tools > HVAC Error Recovery` to view error statistics and manage emergency mode.
+
+### Emergency Mode
+Automatically activated on fatal errors. Disables problematic functionality and sends immediate email alerts.
+
+## Security Monitor
+
+### Features
+- Real-time threat detection
+- Automatic IP blocking for malicious activity
+- Comprehensive security event logging
+- File integrity monitoring
+- Database query analysis
+
+### Monitored Threats
+- **Failed Login Attempts** - Brute force attack detection
+- **SQL Injection** - Pattern detection in requests and queries
+- **XSS Attempts** - Cross-site scripting pattern detection
+- **File Modification** - Critical plugin file integrity checks
+- **Privilege Escalation** - Unauthorized admin actions
+- **Suspicious Activity** - Plugin/theme installation monitoring
+
+### Security Settings
+```php
+$settings = [
+ 'max_failed_logins' => 5,
+ 'lockout_duration' => 900, // 15 minutes
+ 'monitor_file_changes' => true,
+ 'scan_requests' => true,
+ 'alert_threshold' => 3,
+ 'auto_block_ips' => true
+];
+```
+
+### Usage
+
+#### Admin Interface
+Navigate to `Tools > HVAC Security` to view security events, blocked IPs, and threat statistics.
+
+#### WP-CLI
+```bash
+wp hvac security stats
+wp hvac security events
+```
+
+#### REST API
+```
+GET /wp-json/hvac/v1/security/stats
+```
+
+### IP Blocking
+Automatic IP blocking triggers on:
+- 5+ failed login attempts in 1 hour
+- SQL injection attempts
+- Critical threat patterns
+
+## Performance Monitor
+
+### Features
+- Real-time performance tracking
+- Automated performance benchmarks
+- Memory usage monitoring
+- Database query analysis
+- Cache performance tracking
+
+### Performance Metrics
+- **Page Load Time** - Full request processing time
+- **Memory Usage** - Peak memory consumption
+- **Database Queries** - Query count and slow query detection
+- **Cache Hit Rate** - Object cache effectiveness
+- **File I/O Performance** - Disk operation speed
+
+### Thresholds
+```php
+const THRESHOLDS = [
+ 'slow_query_time' => 2.0, // 2 seconds
+ 'memory_usage_mb' => 128, // 128 MB
+ 'page_load_time' => 3.0, // 3 seconds
+ 'db_query_count' => 100, // 100 queries per request
+ 'cache_hit_rate' => 70 // 70% cache hit rate
+];
+```
+
+### Usage
+
+#### Admin Interface
+Navigate to `Tools > HVAC Performance` to view performance statistics and run benchmarks.
+
+#### Admin Bar Integration
+Performance stats appear in the admin bar for logged-in administrators.
+
+#### WP-CLI
+```bash
+wp hvac performance stats
+wp hvac performance benchmark
+```
+
+#### REST API
+```
+GET /wp-json/hvac/v1/performance/stats
+```
+
+### Benchmarking
+Automated daily benchmarks test:
+- Database query performance
+- Memory allocation speed
+- Cache read/write operations
+- File I/O performance
+
+Performance degradation detection compares current benchmarks with previous results and alerts on 50%+ degradation.
+
+## Deployment Validation
+
+### Features
+- 8 critical deployment tests
+- Pre-deployment validation
+- Performance benchmarks during validation
+- Security configuration checks
+
+### Validation Tests
+1. **Plugin Activation** - Verifies plugin is active with correct version
+2. **Database Connectivity** - Tests database connection and queries
+3. **Required Pages** - Checks all plugin pages exist with templates
+4. **User Roles** - Validates HVAC trainer roles and capabilities
+5. **Essential Functionality** - Tests shortcodes, background jobs, health monitoring
+6. **Third Party Integrations** - Verifies The Events Calendar and theme integration
+7. **Performance Benchmarks** - Runs performance tests during deployment
+8. **Security Configurations** - Checks file permissions, nonce system, debug settings
+
+### Usage
+
+#### Command Line
+```bash
+php /path/to/plugin/scripts/deployment-validator.php
+```
+
+#### WP-CLI
+```bash
+wp hvac deployment
+```
+
+### Integration with Deployment Scripts
+Add to your deployment scripts:
+```bash
+# Run deployment validation
+if ! wp hvac deployment; then
+ echo "Deployment validation failed!"
+ exit 1
+fi
+```
+
+## Integration and Architecture
+
+### Singleton Pattern
+All monitoring classes use the singleton pattern to prevent duplicate initialization:
+```php
+HVAC_Health_Monitor::init();
+HVAC_Error_Recovery::init();
+HVAC_Security_Monitor::init();
+HVAC_Performance_Monitor::init();
+```
+
+### WordPress Integration
+- **Cron Jobs** - Automated scheduling for health checks and benchmarks
+- **Admin Menus** - Integrated admin interfaces under Tools menu
+- **REST API** - RESTful endpoints for external monitoring
+- **WP-CLI** - Command-line interface for automation
+- **Admin Bar** - Real-time performance stats
+
+### Database Storage
+- Uses WordPress options table for configuration and metrics
+- Automatic cleanup prevents database bloat
+- Transient caching for frequently accessed data
+
+### Error Handling
+- Comprehensive error logging through HVAC_Logger
+- Fail-safe mechanisms prevent monitoring from breaking site
+- Graceful degradation when monitoring systems fail
+
+## Configuration
+
+### Health Monitor Settings
+```php
+update_option('hvac_health_settings', [
+ 'check_frequency' => 'hourly',
+ 'alert_email' => 'admin@example.com',
+ 'cache_duration' => 300
+]);
+```
+
+### Security Monitor Settings
+```php
+update_option('hvac_security_settings', [
+ 'max_failed_logins' => 5,
+ 'lockout_duration' => 900,
+ 'monitor_file_changes' => true,
+ 'auto_block_ips' => true
+]);
+```
+
+### Performance Monitor Settings
+```php
+update_option('hvac_performance_settings', [
+ 'email_alerts' => true,
+ 'alert_threshold' => 3,
+ 'benchmark_frequency' => 'daily'
+]);
+```
+
+## Troubleshooting
+
+### Common Issues
+
+#### Health Checks Failing
+1. Check database connectivity
+2. Verify file permissions
+3. Ensure The Events Calendar is active
+4. Check WordPress cron system
+
+#### Security Alerts Not Working
+1. Verify admin email setting
+2. Check email delivery system
+3. Review security event logs
+4. Test manual alert trigger
+
+#### Performance Monitoring Inactive
+1. Ensure monitoring conditions are met
+2. Check if request should be monitored
+3. Verify performance thresholds
+4. Review performance event logs
+
+### Debug Mode
+Enable debug logging for detailed monitoring information:
+```php
+define('HVAC_DEBUG_MONITORING', true);
+```
+
+### Log Files
+Monitor logs for system health:
+- WordPress debug.log
+- HVAC_Logger entries
+- Server error logs
+
+## Best Practices
+
+### Production Deployment
+1. Always run deployment validation before going live
+2. Monitor health checks for first 24 hours post-deployment
+3. Review security events regularly
+4. Set up external monitoring for REST API endpoints
+
+### Performance Optimization
+1. Enable object caching for better cache hit rates
+2. Monitor slow query logs and optimize problematic queries
+3. Use performance benchmarks to identify degradation trends
+4. Configure appropriate performance thresholds
+
+### Security Hardening
+1. Enable automatic IP blocking
+2. Monitor file integrity checks
+3. Review security events weekly
+4. Configure security alert thresholds appropriately
+
+### Maintenance
+1. Review and clean old monitoring data monthly
+2. Update performance thresholds based on site growth
+3. Test emergency recovery procedures quarterly
+4. Document any custom monitoring configurations
+
+## API Reference
+
+### Health Monitor API
+```php
+// Run all health checks
+$results = HVAC_Health_Monitor::run_all_checks($force_refresh = false);
+
+// Check overall health status
+$status = $results['overall_status']; // 'healthy', 'warning', 'critical'
+```
+
+### Error Recovery API
+```php
+// Execute with recovery
+$result = HVAC_Error_Recovery::execute_with_recovery($type, $callback, $args);
+
+// Check emergency mode
+$is_emergency = HVAC_Error_Recovery::is_emergency_mode();
+```
+
+### Security Monitor API
+```php
+// Get security statistics
+$stats = HVAC_Security_Monitor::get_security_stats();
+
+// Trigger emergency lockdown
+HVAC_Security_Monitor::emergency_lockdown();
+```
+
+### Performance Monitor API
+```php
+// Get performance statistics
+$stats = HVAC_Performance_Monitor::get_performance_stats();
+
+// Run benchmark
+HVAC_Performance_Monitor::run_performance_benchmark();
+```
+
+## Support and Maintenance
+
+This monitoring system is designed to be self-maintaining with automatic cleanup and intelligent alerting. For issues or questions:
+
+1. Check the admin interfaces for immediate insights
+2. Review log files for detailed error information
+3. Use WP-CLI commands for automation and testing
+4. Consult this documentation for configuration options
+
+The system is designed to fail gracefully - if monitoring systems encounter issues, they will not impact the main plugin functionality.
\ No newline at end of file
diff --git a/includes/class-hvac-backup-manager.php b/includes/class-hvac-backup-manager.php
new file mode 100644
index 00000000..27209660
--- /dev/null
+++ b/includes/class-hvac-backup-manager.php
@@ -0,0 +1,1413 @@
+ true,
+ 'backup_frequency' => 'daily',
+ 'retention_days' => 30,
+ 'backup_location' => 'local', // local, s3, ftp
+ 'compression_enabled' => true,
+ 'encryption_enabled' => true,
+ 'max_backup_size_mb' => 500,
+ 'backup_critical_only' => false
+ ];
+
+ /**
+ * Critical data tables and options
+ */
+ private static $critical_data = [
+ 'tables' => [
+ 'posts',
+ 'postmeta',
+ 'users',
+ 'usermeta',
+ 'options'
+ ],
+ 'options' => [
+ 'hvac_*',
+ 'tribe_events_*',
+ 'astra_*'
+ ],
+ 'files' => [
+ 'uploads/hvac-*',
+ 'plugins/hvac-community-events'
+ ]
+ ];
+
+ /**
+ * Initialize backup manager
+ */
+ public static function init() {
+ // Load settings
+ self::$settings = array_merge(
+ self::$settings,
+ get_option('hvac_backup_settings', [])
+ );
+
+ // Schedule automatic backups
+ if (self::$settings['auto_backup_enabled']) {
+ self::schedule_automatic_backups();
+ }
+
+ // Hook backup actions
+ add_action('hvac_run_backup', [__CLASS__, 'run_scheduled_backup']);
+ add_action('hvac_cleanup_old_backups', [__CLASS__, 'cleanup_old_backups']);
+
+ // Emergency backup triggers
+ add_action('hvac_before_critical_operation', [__CLASS__, 'create_emergency_backup']);
+ add_action('wp_upgrade', [__CLASS__, 'create_pre_update_backup']);
+ add_action('upgrader_process_complete', [__CLASS__, 'create_post_update_backup'], 10, 2);
+
+ // Admin interface
+ if (is_admin()) {
+ add_action('admin_menu', [__CLASS__, 'add_admin_menu']);
+ add_action('wp_ajax_hvac_backup_action', [__CLASS__, 'handle_backup_action']);
+ add_action('admin_notices', [__CLASS__, 'show_backup_notices']);
+ }
+
+ // REST API endpoints
+ add_action('rest_api_init', [__CLASS__, 'register_rest_endpoints']);
+
+ // WP-CLI integration
+ if (defined('WP_CLI') && WP_CLI) {
+ WP_CLI::add_command('hvac backup', [__CLASS__, 'wp_cli_backup']);
+ }
+
+ // Disaster recovery detection
+ add_action('init', [__CLASS__, 'check_disaster_recovery_mode']);
+ }
+
+ /**
+ * Schedule automatic backups
+ */
+ private static function schedule_automatic_backups() {
+ $frequency = self::$settings['backup_frequency'];
+
+ if (!wp_next_scheduled('hvac_run_backup')) {
+ wp_schedule_event(time(), $frequency, 'hvac_run_backup');
+ }
+
+ // Schedule cleanup
+ if (!wp_next_scheduled('hvac_cleanup_old_backups')) {
+ wp_schedule_event(time(), 'daily', 'hvac_cleanup_old_backups');
+ }
+ }
+
+ /**
+ * Create backup
+ *
+ * @param string $type Backup type
+ * @param array $options Backup options
+ * @return array Backup result
+ */
+ public static function create_backup($type = self::BACKUP_FULL, $options = []) {
+ $backup_id = uniqid('hvac_backup_');
+ $timestamp = time();
+
+ // Default options
+ $options = array_merge([
+ 'compress' => self::$settings['compression_enabled'],
+ 'encrypt' => self::$settings['encryption_enabled'],
+ 'description' => '',
+ 'triggered_by' => 'manual'
+ ], $options);
+
+ // Create backup record
+ $backup_record = [
+ 'id' => $backup_id,
+ 'type' => $type,
+ 'status' => self::STATUS_RUNNING,
+ 'created_at' => $timestamp,
+ 'size' => 0,
+ 'file_path' => '',
+ 'options' => $options,
+ 'progress' => 0
+ ];
+
+ self::update_backup_record($backup_id, $backup_record);
+
+ try {
+ // Create backup directory
+ $backup_dir = self::get_backup_directory();
+ if (!wp_mkdir_p($backup_dir)) {
+ throw new Exception('Failed to create backup directory');
+ }
+
+ $backup_file = $backup_dir . "/{$backup_id}.sql";
+
+ // Perform backup based on type
+ switch ($type) {
+ case self::BACKUP_FULL:
+ $result = self::create_full_backup($backup_file, $backup_id);
+ break;
+
+ case self::BACKUP_CRITICAL_DATA:
+ $result = self::create_critical_data_backup($backup_file, $backup_id);
+ break;
+
+ case self::BACKUP_INCREMENTAL:
+ $result = self::create_incremental_backup($backup_file, $backup_id);
+ break;
+
+ default:
+ throw new Exception('Invalid backup type');
+ }
+
+ // Post-processing
+ if ($result['success']) {
+ $final_file = $result['file_path'];
+
+ // Compress if enabled
+ if ($options['compress']) {
+ $final_file = self::compress_backup($final_file);
+ }
+
+ // Encrypt if enabled
+ if ($options['encrypt']) {
+ $final_file = self::encrypt_backup($final_file);
+ }
+
+ $file_size = file_exists($final_file) ? filesize($final_file) : 0;
+
+ // Update backup record
+ $backup_record['status'] = self::STATUS_COMPLETED;
+ $backup_record['file_path'] = $final_file;
+ $backup_record['size'] = $file_size;
+ $backup_record['progress'] = 100;
+ $backup_record['completed_at'] = time();
+
+ self::update_backup_record($backup_id, $backup_record);
+
+ // Log success
+ HVAC_Logger::info(
+ "Backup completed successfully: $backup_id ($type)",
+ 'Backup Manager'
+ );
+
+ return [
+ 'success' => true,
+ 'backup_id' => $backup_id,
+ 'file_path' => $final_file,
+ 'size' => $file_size
+ ];
+ } else {
+ throw new Exception($result['error']);
+ }
+
+ } catch (Exception $e) {
+ // Update backup record with failure
+ $backup_record['status'] = self::STATUS_FAILED;
+ $backup_record['error'] = $e->getMessage();
+ self::update_backup_record($backup_id, $backup_record);
+
+ HVAC_Logger::error(
+ "Backup failed: $backup_id - " . $e->getMessage(),
+ 'Backup Manager'
+ );
+
+ return [
+ 'success' => false,
+ 'error' => $e->getMessage(),
+ 'backup_id' => $backup_id
+ ];
+ }
+ }
+
+ /**
+ * Create full backup
+ */
+ private static function create_full_backup($backup_file, $backup_id) {
+ global $wpdb;
+
+ try {
+ // Get all tables
+ $tables = $wpdb->get_results('SHOW TABLES', ARRAY_N);
+ $total_tables = count($tables);
+ $current_table = 0;
+
+ $sql_content = "-- HVAC Plugin Full Backup\n";
+ $sql_content .= "-- Created: " . date('Y-m-d H:i:s') . "\n";
+ $sql_content .= "-- Backup ID: $backup_id\n\n";
+
+ foreach ($tables as $table) {
+ $table_name = $table[0];
+ $current_table++;
+
+ // Update progress
+ $progress = ($current_table / $total_tables) * 90; // 90% for database, 10% for files
+ self::update_backup_progress($backup_id, $progress);
+
+ // Export table structure
+ $create_table = $wpdb->get_row("SHOW CREATE TABLE `$table_name`", ARRAY_N);
+ $sql_content .= "\n-- Table structure for `$table_name`\n";
+ $sql_content .= "DROP TABLE IF EXISTS `$table_name`;\n";
+ $sql_content .= $create_table[1] . ";\n\n";
+
+ // Export table data
+ $rows = $wpdb->get_results("SELECT * FROM `$table_name`", ARRAY_A);
+ if (!empty($rows)) {
+ $sql_content .= "-- Data for table `$table_name`\n";
+
+ foreach ($rows as $row) {
+ $values = array_map(function($value) {
+ return is_null($value) ? 'NULL' : "'" . esc_sql($value) . "'";
+ }, array_values($row));
+
+ $sql_content .= "INSERT INTO `$table_name` VALUES (" .
+ implode(', ', $values) . ");\n";
+ }
+ $sql_content .= "\n";
+ }
+ }
+
+ // Write SQL file
+ $bytes_written = file_put_contents($backup_file, $sql_content);
+ if ($bytes_written === false) {
+ throw new Exception('Failed to write backup file');
+ }
+
+ // Update progress to 100%
+ self::update_backup_progress($backup_id, 100);
+
+ return [
+ 'success' => true,
+ 'file_path' => $backup_file,
+ 'tables_exported' => $total_tables,
+ 'size' => $bytes_written
+ ];
+
+ } catch (Exception $e) {
+ return [
+ 'success' => false,
+ 'error' => $e->getMessage()
+ ];
+ }
+ }
+
+ /**
+ * Create critical data backup
+ */
+ private static function create_critical_data_backup($backup_file, $backup_id) {
+ global $wpdb;
+
+ try {
+ $sql_content = "-- HVAC Plugin Critical Data Backup\n";
+ $sql_content .= "-- Created: " . date('Y-m-d H:i:s') . "\n";
+ $sql_content .= "-- Backup ID: $backup_id\n\n";
+
+ $critical_tables = self::$critical_data['tables'];
+ $total_tables = count($critical_tables);
+ $current_table = 0;
+
+ foreach ($critical_tables as $table_suffix) {
+ $table_name = $wpdb->prefix . $table_suffix;
+ $current_table++;
+
+ // Update progress
+ $progress = ($current_table / $total_tables) * 100;
+ self::update_backup_progress($backup_id, $progress);
+
+ // Check if table exists
+ $table_exists = $wpdb->get_var($wpdb->prepare(
+ "SHOW TABLES LIKE %s",
+ $table_name
+ ));
+
+ if (!$table_exists) {
+ continue;
+ }
+
+ // Export critical data from this table
+ if ($table_suffix === 'options') {
+ // Export critical options only
+ $sql_content .= self::export_critical_options($table_name);
+ } elseif ($table_suffix === 'posts') {
+ // Export HVAC-related posts only
+ $sql_content .= self::export_hvac_posts($table_name);
+ } else {
+ // Export full table for other critical tables
+ $sql_content .= self::export_full_table($table_name);
+ }
+ }
+
+ // Write SQL file
+ $bytes_written = file_put_contents($backup_file, $sql_content);
+ if ($bytes_written === false) {
+ throw new Exception('Failed to write critical data backup file');
+ }
+
+ return [
+ 'success' => true,
+ 'file_path' => $backup_file,
+ 'tables_exported' => count($critical_tables),
+ 'size' => $bytes_written
+ ];
+
+ } catch (Exception $e) {
+ return [
+ 'success' => false,
+ 'error' => $e->getMessage()
+ ];
+ }
+ }
+
+ /**
+ * Export critical options
+ */
+ private static function export_critical_options($table_name) {
+ global $wpdb;
+
+ $sql = "\n-- Critical Options from $table_name\n";
+
+ foreach (self::$critical_data['options'] as $option_pattern) {
+ $like_pattern = str_replace('*', '%', $option_pattern);
+
+ $options = $wpdb->get_results($wpdb->prepare(
+ "SELECT * FROM `$table_name` WHERE option_name LIKE %s",
+ $like_pattern
+ ), ARRAY_A);
+
+ foreach ($options as $option) {
+ $name = esc_sql($option['option_name']);
+ $value = esc_sql($option['option_value']);
+ $autoload = esc_sql($option['autoload']);
+
+ $sql .= "INSERT INTO `$table_name` (option_name, option_value, autoload) VALUES ";
+ $sql .= "('$name', '$value', '$autoload') ON DUPLICATE KEY UPDATE ";
+ $sql .= "option_value = VALUES(option_value), autoload = VALUES(autoload);\n";
+ }
+ }
+
+ return $sql . "\n";
+ }
+
+ /**
+ * Export HVAC-related posts
+ */
+ private static function export_hvac_posts($table_name) {
+ global $wpdb;
+
+ $sql = "\n-- HVAC-related Posts from $table_name\n";
+
+ // Export tribe_events and HVAC pages
+ $post_types = ['tribe_events', 'page'];
+
+ foreach ($post_types as $post_type) {
+ $posts = $wpdb->get_results($wpdb->prepare(
+ "SELECT * FROM `$table_name` WHERE post_type = %s AND (post_title LIKE %s OR post_name LIKE %s)",
+ $post_type,
+ '%trainer%',
+ '%hvac%'
+ ), ARRAY_A);
+
+ foreach ($posts as $post) {
+ $values = array_map(function($value) {
+ return is_null($value) ? 'NULL' : "'" . esc_sql($value) . "'";
+ }, array_values($post));
+
+ $sql .= "INSERT INTO `$table_name` VALUES (" . implode(', ', $values) . ");\n";
+ }
+ }
+
+ return $sql . "\n";
+ }
+
+ /**
+ * Export full table
+ */
+ private static function export_full_table($table_name) {
+ global $wpdb;
+
+ $sql = "\n-- Full export of $table_name\n";
+
+ // Get table structure
+ $create_table = $wpdb->get_row("SHOW CREATE TABLE `$table_name`", ARRAY_N);
+ $sql .= "DROP TABLE IF EXISTS `$table_name`;\n";
+ $sql .= $create_table[1] . ";\n\n";
+
+ // Get table data
+ $rows = $wpdb->get_results("SELECT * FROM `$table_name`", ARRAY_A);
+
+ foreach ($rows as $row) {
+ $values = array_map(function($value) {
+ return is_null($value) ? 'NULL' : "'" . esc_sql($value) . "'";
+ }, array_values($row));
+
+ $sql .= "INSERT INTO `$table_name` VALUES (" . implode(', ', $values) . ");\n";
+ }
+
+ return $sql . "\n";
+ }
+
+ /**
+ * Create incremental backup
+ */
+ private static function create_incremental_backup($backup_file, $backup_id) {
+ // Get last backup timestamp
+ $last_backup_time = get_option('hvac_last_backup_timestamp', 0);
+ $current_time = time();
+
+ // Find changes since last backup
+ global $wpdb;
+
+ $sql_content = "-- HVAC Plugin Incremental Backup\n";
+ $sql_content .= "-- Created: " . date('Y-m-d H:i:s') . "\n";
+ $sql_content .= "-- Since: " . date('Y-m-d H:i:s', $last_backup_time) . "\n";
+ $sql_content .= "-- Backup ID: $backup_id\n\n";
+
+ // Get modified posts
+ $modified_posts = $wpdb->get_results($wpdb->prepare(
+ "SELECT * FROM {$wpdb->posts} WHERE post_modified_gmt > %s",
+ date('Y-m-d H:i:s', $last_backup_time)
+ ), ARRAY_A);
+
+ if (!empty($modified_posts)) {
+ $sql_content .= "-- Modified Posts\n";
+ foreach ($modified_posts as $post) {
+ $values = array_map(function($value) {
+ return is_null($value) ? 'NULL' : "'" . esc_sql($value) . "'";
+ }, array_values($post));
+
+ $sql_content .= "REPLACE INTO {$wpdb->posts} VALUES (" .
+ implode(', ', $values) . ");\n";
+ }
+ }
+
+ // Get modified options
+ $modified_options = $wpdb->get_results($wpdb->prepare(
+ "SELECT * FROM {$wpdb->options} WHERE option_name LIKE %s",
+ 'hvac_%'
+ ), ARRAY_A);
+
+ if (!empty($modified_options)) {
+ $sql_content .= "\n-- HVAC Options\n";
+ foreach ($modified_options as $option) {
+ $name = esc_sql($option['option_name']);
+ $value = esc_sql($option['option_value']);
+ $autoload = esc_sql($option['autoload']);
+
+ $sql_content .= "REPLACE INTO {$wpdb->options} (option_name, option_value, autoload) ";
+ $sql_content .= "VALUES ('$name', '$value', '$autoload');\n";
+ }
+ }
+
+ // Write incremental backup
+ $bytes_written = file_put_contents($backup_file, $sql_content);
+ if ($bytes_written === false) {
+ throw new Exception('Failed to write incremental backup file');
+ }
+
+ // Update last backup timestamp
+ update_option('hvac_last_backup_timestamp', $current_time);
+
+ return [
+ 'success' => true,
+ 'file_path' => $backup_file,
+ 'modified_posts' => count($modified_posts),
+ 'modified_options' => count($modified_options),
+ 'size' => $bytes_written
+ ];
+ }
+
+ /**
+ * Compress backup file
+ */
+ private static function compress_backup($file_path) {
+ if (!function_exists('gzopen')) {
+ HVAC_Logger::warning('GZ compression not available', 'Backup Manager');
+ return $file_path;
+ }
+
+ $compressed_file = $file_path . '.gz';
+
+ $file_handle = fopen($file_path, 'rb');
+ $gz_handle = gzopen($compressed_file, 'wb9');
+
+ if ($file_handle && $gz_handle) {
+ while (!feof($file_handle)) {
+ gzwrite($gz_handle, fread($file_handle, 4096));
+ }
+
+ fclose($file_handle);
+ gzclose($gz_handle);
+
+ // Remove original file
+ unlink($file_path);
+
+ return $compressed_file;
+ }
+
+ return $file_path;
+ }
+
+ /**
+ * Encrypt backup file
+ */
+ private static function encrypt_backup($file_path) {
+ if (!function_exists('openssl_encrypt')) {
+ HVAC_Logger::warning('OpenSSL encryption not available', 'Backup Manager');
+ return $file_path;
+ }
+
+ $encryption_key = self::get_encryption_key();
+ $encrypted_file = $file_path . '.enc';
+
+ $data = file_get_contents($file_path);
+ $iv = openssl_random_pseudo_bytes(16);
+
+ $encrypted_data = openssl_encrypt(
+ $data,
+ 'AES-256-CBC',
+ $encryption_key,
+ 0,
+ $iv
+ );
+
+ if ($encrypted_data !== false) {
+ // Store IV + encrypted data
+ file_put_contents($encrypted_file, base64_encode($iv . $encrypted_data));
+
+ // Remove original file
+ unlink($file_path);
+
+ return $encrypted_file;
+ }
+
+ return $file_path;
+ }
+
+ /**
+ * Get or generate encryption key
+ */
+ private static function get_encryption_key() {
+ $key = get_option('hvac_backup_encryption_key');
+
+ if (!$key) {
+ $key = bin2hex(openssl_random_pseudo_bytes(32));
+ update_option('hvac_backup_encryption_key', $key);
+ }
+
+ return $key;
+ }
+
+ /**
+ * Restore from backup
+ *
+ * @param string $backup_id Backup ID to restore
+ * @param array $options Restore options
+ * @return array Restore result
+ */
+ public static function restore_from_backup($backup_id, $options = []) {
+ $backup_record = self::get_backup_record($backup_id);
+
+ if (!$backup_record || $backup_record['status'] !== self::STATUS_COMPLETED) {
+ return [
+ 'success' => false,
+ 'error' => 'Backup not found or incomplete'
+ ];
+ }
+
+ $backup_file = $backup_record['file_path'];
+
+ if (!file_exists($backup_file)) {
+ return [
+ 'success' => false,
+ 'error' => 'Backup file not found'
+ ];
+ }
+
+ try {
+ // Create restoration backup first
+ self::create_backup(self::BACKUP_CRITICAL_DATA, [
+ 'description' => 'Pre-restoration backup',
+ 'triggered_by' => 'restore_operation'
+ ]);
+
+ // Decrypt if needed
+ if (str_ends_with($backup_file, '.enc')) {
+ $backup_file = self::decrypt_backup($backup_file);
+ }
+
+ // Decompress if needed
+ if (str_ends_with($backup_file, '.gz')) {
+ $backup_file = self::decompress_backup($backup_file);
+ }
+
+ // Execute SQL restoration
+ $sql_content = file_get_contents($backup_file);
+
+ if ($sql_content === false) {
+ throw new Exception('Failed to read backup file');
+ }
+
+ // Split SQL into individual statements
+ $statements = array_filter(
+ explode(";\n", $sql_content),
+ function($statement) {
+ return trim($statement) && !str_starts_with(trim($statement), '--');
+ }
+ );
+
+ global $wpdb;
+ $executed_statements = 0;
+ $failed_statements = 0;
+
+ foreach ($statements as $statement) {
+ $statement = trim($statement);
+ if (empty($statement)) continue;
+
+ $result = $wpdb->query($statement);
+
+ if ($result === false) {
+ $failed_statements++;
+ HVAC_Logger::warning(
+ "Failed to execute SQL: " . $wpdb->last_error,
+ 'Backup Manager'
+ );
+ } else {
+ $executed_statements++;
+ }
+ }
+
+ // Clear all caches
+ wp_cache_flush();
+
+ // Log successful restoration
+ HVAC_Logger::info(
+ "Backup restored successfully: $backup_id ($executed_statements statements)",
+ 'Backup Manager'
+ );
+
+ return [
+ 'success' => true,
+ 'executed_statements' => $executed_statements,
+ 'failed_statements' => $failed_statements,
+ 'backup_id' => $backup_id
+ ];
+
+ } catch (Exception $e) {
+ HVAC_Logger::error(
+ "Backup restoration failed: $backup_id - " . $e->getMessage(),
+ 'Backup Manager'
+ );
+
+ return [
+ 'success' => false,
+ 'error' => $e->getMessage(),
+ 'backup_id' => $backup_id
+ ];
+ }
+ }
+
+ /**
+ * Decrypt backup file
+ */
+ private static function decrypt_backup($encrypted_file) {
+ $encryption_key = self::get_encryption_key();
+ $decrypted_file = str_replace('.enc', '', $encrypted_file);
+
+ $encrypted_data = base64_decode(file_get_contents($encrypted_file));
+ $iv = substr($encrypted_data, 0, 16);
+ $data = substr($encrypted_data, 16);
+
+ $decrypted_data = openssl_decrypt(
+ $data,
+ 'AES-256-CBC',
+ $encryption_key,
+ 0,
+ $iv
+ );
+
+ if ($decrypted_data !== false) {
+ file_put_contents($decrypted_file, $decrypted_data);
+ return $decrypted_file;
+ }
+
+ throw new Exception('Failed to decrypt backup file');
+ }
+
+ /**
+ * Decompress backup file
+ */
+ private static function decompress_backup($compressed_file) {
+ $decompressed_file = str_replace('.gz', '', $compressed_file);
+
+ $gz_handle = gzopen($compressed_file, 'rb');
+ $file_handle = fopen($decompressed_file, 'wb');
+
+ if ($gz_handle && $file_handle) {
+ while (!gzeof($gz_handle)) {
+ fwrite($file_handle, gzread($gz_handle, 4096));
+ }
+
+ gzclose($gz_handle);
+ fclose($file_handle);
+
+ return $decompressed_file;
+ }
+
+ throw new Exception('Failed to decompress backup file');
+ }
+
+ /**
+ * Run scheduled backup
+ */
+ public static function run_scheduled_backup() {
+ $backup_type = self::$settings['backup_critical_only'] ?
+ self::BACKUP_CRITICAL_DATA :
+ self::BACKUP_FULL;
+
+ $result = self::create_backup($backup_type, [
+ 'description' => 'Scheduled automatic backup',
+ 'triggered_by' => 'scheduler'
+ ]);
+
+ if ($result['success']) {
+ HVAC_Logger::info(
+ 'Scheduled backup completed: ' . $result['backup_id'],
+ 'Backup Manager'
+ );
+ } else {
+ HVAC_Logger::error(
+ 'Scheduled backup failed: ' . $result['error'],
+ 'Backup Manager'
+ );
+
+ // Send alert email
+ self::send_backup_alert('Scheduled Backup Failed', [
+ 'error' => $result['error'],
+ 'timestamp' => time()
+ ]);
+ }
+ }
+
+ /**
+ * Create emergency backup
+ */
+ public static function create_emergency_backup() {
+ $result = self::create_backup(self::BACKUP_CRITICAL_DATA, [
+ 'description' => 'Emergency backup before critical operation',
+ 'triggered_by' => 'emergency'
+ ]);
+
+ if (!$result['success']) {
+ HVAC_Logger::error(
+ 'Emergency backup failed: ' . $result['error'],
+ 'Backup Manager'
+ );
+ }
+
+ return $result;
+ }
+
+ /**
+ * Create pre-update backup
+ */
+ public static function create_pre_update_backup() {
+ self::create_backup(self::BACKUP_FULL, [
+ 'description' => 'Pre-WordPress update backup',
+ 'triggered_by' => 'wp_update'
+ ]);
+ }
+
+ /**
+ * Create post-update backup
+ */
+ public static function create_post_update_backup($upgrader, $options) {
+ if ($options['type'] === 'plugin' &&
+ isset($options['plugins']) &&
+ in_array('hvac-community-events/hvac-community-events.php', $options['plugins'])) {
+
+ self::create_backup(self::BACKUP_CRITICAL_DATA, [
+ 'description' => 'Post-plugin update backup',
+ 'triggered_by' => 'plugin_update'
+ ]);
+ }
+ }
+
+ /**
+ * Cleanup old backups
+ */
+ public static function cleanup_old_backups() {
+ $retention_days = self::$settings['retention_days'];
+ $cutoff_timestamp = time() - ($retention_days * 86400);
+
+ $backups = self::get_all_backups();
+ $cleaned_count = 0;
+
+ foreach ($backups as $backup_id => $backup) {
+ if ($backup['created_at'] < $cutoff_timestamp) {
+ if (self::delete_backup($backup_id)) {
+ $cleaned_count++;
+ }
+ }
+ }
+
+ if ($cleaned_count > 0) {
+ HVAC_Logger::info(
+ "Cleaned up $cleaned_count old backups",
+ 'Backup Manager'
+ );
+ }
+ }
+
+ /**
+ * Delete backup
+ */
+ public static function delete_backup($backup_id) {
+ $backup_record = self::get_backup_record($backup_id);
+
+ if ($backup_record && !empty($backup_record['file_path'])) {
+ if (file_exists($backup_record['file_path'])) {
+ unlink($backup_record['file_path']);
+ }
+ }
+
+ // Remove from records
+ $backups = get_option('hvac_backups', []);
+ unset($backups[$backup_id]);
+ update_option('hvac_backups', $backups);
+
+ return true;
+ }
+
+ /**
+ * Get backup directory
+ */
+ private static function get_backup_directory() {
+ $upload_dir = wp_upload_dir();
+ return $upload_dir['basedir'] . '/hvac-backups';
+ }
+
+ /**
+ * Update backup record
+ */
+ private static function update_backup_record($backup_id, $record) {
+ $backups = get_option('hvac_backups', []);
+ $backups[$backup_id] = $record;
+ update_option('hvac_backups', $backups);
+ }
+
+ /**
+ * Get backup record
+ */
+ private static function get_backup_record($backup_id) {
+ $backups = get_option('hvac_backups', []);
+ return $backups[$backup_id] ?? null;
+ }
+
+ /**
+ * Get all backups
+ */
+ public static function get_all_backups() {
+ return get_option('hvac_backups', []);
+ }
+
+ /**
+ * Update backup progress
+ */
+ private static function update_backup_progress($backup_id, $progress) {
+ $backup_record = self::get_backup_record($backup_id);
+ if ($backup_record) {
+ $backup_record['progress'] = $progress;
+ self::update_backup_record($backup_id, $backup_record);
+ }
+ }
+
+ /**
+ * Check disaster recovery mode
+ */
+ public static function check_disaster_recovery_mode() {
+ $recovery_mode = get_option('hvac_disaster_recovery_mode', false);
+
+ if ($recovery_mode) {
+ // Display disaster recovery notice
+ add_action('admin_notices', function() use ($recovery_mode) {
+ echo '';
+ echo '
Disaster Recovery Mode Active
';
+ echo '
Last backup: ' . date('Y-m-d H:i:s', $recovery_mode['timestamp']) . '
';
+ echo '
Issue: ' . esc_html($recovery_mode['issue']) . '
';
+ echo '
+
HVAC Backup Manager
+
+
+
+
Backup Overview
+
Total Backups:
+
Completed:
+
Failed:
+
Total Size:
+
+
Last Backup:
+
+
+
Next Scheduled:
+
+
+
+
+
Create New Backup
+
+
+
+
+
+
+
+
+
Recent Backups
+
+
+
+ | Backup ID |
+ Type |
+ Status |
+ Created |
+ Size |
+ Actions |
+
+
+
+
+
+ | No backups found |
+
+
+ $backup): ?>
+
+ |
+ |
+ |
+ |
+ |
+
+
+
+
+
+ |
+
+
+
+
+
+
+
+
+
+
+
';
+ echo '
HVAC Backup Warning: No recent backups found. ';
+ echo 'Create a backup now
';
+ echo '
';
+ echo '
HVAC Backup Error: Recent backup failures detected. ';
+ echo 'Check backup status
';
+ echo '
+
HVAC Cache Optimizer
+
+
+
+
Cache Performance
+
Hit Rate: %
+
Memory Usage:
+
Strategy:
+
Total Operations:
+
+
+
+
Cache Operations
+
Cache Hits:
+
Cache Misses:
+
Cache Sets:
+
Cache Deletes:
+
Cache Flushes:
+
+
+
+
Cache Management
+
+
+
+
+
+
+
+
+
+
+
+
Cache Groups
+
+
+
+ | Group |
+ Description |
+ Actions |
+
+
+
+ 'Event listings and event data',
+ self::CACHE_GROUP_TRAINERS => 'Trainer profiles and trainer data',
+ self::CACHE_GROUP_CERTIFICATES => 'Certificate data and generation',
+ self::CACHE_GROUP_DASHBOARD => 'Dashboard statistics and metrics',
+ self::CACHE_GROUP_API => 'API responses and external data'
+ ];
+ ?>
+
+
+ |
+ |
+
+
+ |
+
+
+
+
+
+
+
+
Cache Strategy Settings
+
+
+
+
+
+
+
+
HVAC Error Recovery System
+
+
+
+
Emergency Mode Active - Some plugin functionality may be disabled due to critical errors.
+
+
+
+
+
+
+
+
Error Statistics
+
+
+
+ | Operation Type |
+ Error Count |
+ Circuit Breaker |
+
+
+
+
+
+ | No errors recorded |
+
+
+ $count): ?>
+
+ |
+ |
+
+ time()) {
+ echo 'OPEN (expires: ' . date('H:i:s', $breaker_expiry) . ')';
+ } else {
+ echo 'CLOSED';
+ }
+ ?>
+ |
+
+
+
+
+
+
+
+
+
Recovery Configuration
+
The error recovery system is configured with the following strategies:
+
+ - Database Queries: Retry with exponential backoff (3 attempts)
+ - Cache Operations: Skip and continue without caching
+ - External APIs: Circuit breaker with 5-minute timeout
+ - File Operations: Graceful failure with safe defaults
+
+
+
+
HVAC Health Monitor
+
+
+
Overall Status:
+
+
+
+
+
Last checked:
+
+
+
+
+
+
+ $check): ?>
+
+
+
Status:
+
+
Checked in: s
+
+
+
+ Details
+
+
+
+
+
+
+
+
+
+
+
';
+ echo 'HVAC Plugin Health Alert: Critical issues detected. ';
+ echo 'View Details';
+ echo '
';
+ }
+ }
+
+ /**
+ * Register REST endpoints
+ */
+ public static function register_rest_endpoints() {
+ register_rest_route('hvac/v1', '/health', [
+ 'methods' => 'GET',
+ 'callback' => [__CLASS__, 'rest_health_check'],
+ 'permission_callback' => function() {
+ return current_user_can('manage_options');
+ }
+ ]);
+ }
+
+ /**
+ * REST API health check
+ */
+ public static function rest_health_check() {
+ $results = self::run_all_checks();
+
+ return new WP_REST_Response([
+ 'status' => $results['overall_status'],
+ 'timestamp' => $results['timestamp'],
+ 'checks' => $results['checks']
+ ], 200);
+ }
+
+ /**
+ * WP-CLI health check command
+ */
+ public static function wp_cli_health_check($args, $assoc_args) {
+ WP_CLI::line('Running HVAC health checks...');
+
+ $results = self::run_all_checks(true);
+
+ WP_CLI::line('Overall Status: ' . strtoupper($results['overall_status']));
+ WP_CLI::line('');
+
+ foreach ($results['checks'] as $type => $check) {
+ $status_color = $check['status'] === self::STATUS_HEALTHY ? '%G' :
+ ($check['status'] === self::STATUS_WARNING ? '%Y' : '%R');
+
+ WP_CLI::line(sprintf(
+ '%s: ' . $status_color . '%s%n - %s',
+ $check['name'],
+ strtoupper($check['status']),
+ $check['message']
+ ));
+ }
+
+ if ($results['overall_status'] !== self::STATUS_HEALTHY) {
+ WP_CLI::error('Health checks failed with issues', false);
+ } else {
+ WP_CLI::success('All health checks passed');
+ }
+ }
+}
\ No newline at end of file
diff --git a/includes/class-hvac-performance-monitor.php b/includes/class-hvac-performance-monitor.php
new file mode 100644
index 00000000..7e5c2ea6
--- /dev/null
+++ b/includes/class-hvac-performance-monitor.php
@@ -0,0 +1,951 @@
+ 2.0, // 2 seconds
+ 'memory_usage_mb' => 128, // 128 MB
+ 'page_load_time' => 3.0, // 3 seconds
+ 'cpu_usage_percent' => 80, // 80%
+ 'db_query_count' => 100, // 100 queries per request
+ 'cache_hit_rate' => 70 // 70% cache hit rate
+ ];
+
+ /**
+ * Performance metrics
+ */
+ private static $metrics = [];
+ private static $query_log = [];
+ private static $memory_checkpoints = [];
+ private static $start_time;
+ private static $start_memory;
+
+ /**
+ * Alert settings
+ */
+ private static $alert_settings = [
+ 'email_alerts' => true,
+ 'slack_webhook' => '',
+ 'alert_threshold' => 3, // Number of incidents before alert
+ 'alert_cooldown' => 1800, // 30 minutes between alerts
+ 'benchmark_frequency' => 'daily'
+ ];
+
+ /**
+ * Initialize performance monitoring
+ */
+ public static function init() {
+ // Load settings
+ self::$alert_settings = array_merge(
+ self::$alert_settings,
+ get_option('hvac_performance_settings', [])
+ );
+
+ // Set initial measurements
+ self::$start_time = microtime(true);
+ self::$start_memory = memory_get_usage(true);
+
+ // Hook into WordPress performance points
+ add_action('init', [__CLASS__, 'start_monitoring'], 0);
+ add_action('wp_loaded', [__CLASS__, 'checkpoint_loaded']);
+ add_action('wp_footer', [__CLASS__, 'checkpoint_footer']);
+ add_action('shutdown', [__CLASS__, 'finalize_monitoring']);
+
+ // Database query monitoring
+ add_filter('query', [__CLASS__, 'monitor_query']);
+ add_action('wp_db_query', [__CLASS__, 'log_query_completion']);
+
+ // Memory monitoring
+ add_action('wp_loaded', [__CLASS__, 'checkpoint_memory']);
+ add_action('wp_footer', [__CLASS__, 'checkpoint_memory']);
+
+ // Schedule performance benchmarks
+ if (!wp_next_scheduled('hvac_performance_benchmark')) {
+ $frequency = self::$alert_settings['benchmark_frequency'];
+ wp_schedule_event(time(), $frequency, 'hvac_performance_benchmark');
+ }
+
+ add_action('hvac_performance_benchmark', [__CLASS__, 'run_performance_benchmark']);
+
+ // Admin interface
+ if (is_admin()) {
+ add_action('admin_menu', [__CLASS__, 'add_admin_menu']);
+ add_action('wp_ajax_hvac_performance_action', [__CLASS__, 'handle_performance_action']);
+ add_action('admin_bar_menu', [__CLASS__, 'add_admin_bar_stats'], 999);
+ }
+
+ // REST API endpoints
+ add_action('rest_api_init', [__CLASS__, 'register_rest_endpoints']);
+
+ // WP-CLI integration
+ if (defined('WP_CLI') && WP_CLI) {
+ WP_CLI::add_command('hvac performance', [__CLASS__, 'wp_cli_performance']);
+ }
+
+ // Emergency alerts for critical performance issues
+ add_action('hvac_critical_performance_issue', [__CLASS__, 'handle_critical_issue']);
+ }
+
+ /**
+ * Start monitoring
+ */
+ public static function start_monitoring() {
+ // Only monitor frontend requests and specific admin pages
+ if (!self::should_monitor()) {
+ return;
+ }
+
+ self::$metrics['start_time'] = microtime(true);
+ self::$metrics['start_memory'] = memory_get_usage(true);
+ self::$metrics['query_count'] = 0;
+ self::$metrics['slow_queries'] = [];
+
+ // Set up query monitoring
+ global $wpdb;
+ $wpdb->save_queries = true;
+ }
+
+ /**
+ * Check if we should monitor this request
+ */
+ private static function should_monitor() {
+ // Skip monitoring for certain requests
+ if (wp_doing_ajax() || wp_doing_cron() || (defined('WP_CLI') && WP_CLI)) {
+ return false;
+ }
+
+ // Skip for admin unless it's a plugin page
+ if (is_admin()) {
+ $screen = get_current_screen();
+ if (!$screen || strpos($screen->id, 'hvac') === false) {
+ return false;
+ }
+ }
+
+ // Skip for REST API unless it's our endpoints
+ if (defined('REST_REQUEST') && REST_REQUEST) {
+ $request_uri = $_SERVER['REQUEST_URI'] ?? '';
+ if (strpos($request_uri, '/hvac/v1/') === false) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Monitor database queries
+ */
+ public static function monitor_query($query) {
+ if (!isset(self::$metrics['start_time'])) {
+ return $query;
+ }
+
+ $start_time = microtime(true);
+
+ // Store query info for monitoring
+ self::$query_log[] = [
+ 'query' => $query,
+ 'start_time' => $start_time,
+ 'backtrace' => debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 5)
+ ];
+
+ return $query;
+ }
+
+ /**
+ * Log query completion
+ */
+ public static function log_query_completion($result) {
+ if (empty(self::$query_log)) {
+ return;
+ }
+
+ $current_query = &self::$query_log[count(self::$query_log) - 1];
+ $execution_time = microtime(true) - $current_query['start_time'];
+ $current_query['execution_time'] = $execution_time;
+
+ self::$metrics['query_count']++;
+
+ // Check for slow queries
+ if ($execution_time > self::THRESHOLDS['slow_query_time']) {
+ self::$metrics['slow_queries'][] = [
+ 'query' => substr($current_query['query'], 0, 200),
+ 'time' => $execution_time,
+ 'backtrace' => $current_query['backtrace']
+ ];
+
+ // Log slow query
+ HVAC_Logger::warning(
+ "Slow query detected: {$execution_time}s - " . substr($current_query['query'], 0, 100),
+ 'Performance Monitor'
+ );
+ }
+ }
+
+ /**
+ * Memory checkpoint
+ */
+ public static function checkpoint_memory($checkpoint = null) {
+ if (!isset(self::$metrics['start_time'])) {
+ return;
+ }
+
+ $current_memory = memory_get_usage(true);
+ $peak_memory = memory_get_peak_usage(true);
+
+ if ($checkpoint === null) {
+ $checkpoint = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0]['function'];
+ }
+
+ self::$memory_checkpoints[] = [
+ 'checkpoint' => $checkpoint,
+ 'time' => microtime(true),
+ 'current_memory' => $current_memory,
+ 'peak_memory' => $peak_memory,
+ 'memory_mb' => round($current_memory / 1024 / 1024, 2)
+ ];
+
+ // Check for memory threshold breach
+ $memory_mb = $current_memory / 1024 / 1024;
+ if ($memory_mb > self::THRESHOLDS['memory_usage_mb']) {
+ HVAC_Logger::warning(
+ "High memory usage detected: {$memory_mb}MB at checkpoint: $checkpoint",
+ 'Performance Monitor'
+ );
+ }
+ }
+
+ /**
+ * Checkpoint: WordPress loaded
+ */
+ public static function checkpoint_loaded() {
+ self::checkpoint_memory('wp_loaded');
+ }
+
+ /**
+ * Checkpoint: Footer
+ */
+ public static function checkpoint_footer() {
+ self::checkpoint_memory('wp_footer');
+ }
+
+ /**
+ * Finalize monitoring
+ */
+ public static function finalize_monitoring() {
+ if (!isset(self::$metrics['start_time'])) {
+ return;
+ }
+
+ $end_time = microtime(true);
+ $total_time = $end_time - self::$metrics['start_time'];
+ $peak_memory = memory_get_peak_usage(true);
+ $peak_memory_mb = $peak_memory / 1024 / 1024;
+
+ // Finalize metrics
+ self::$metrics['total_time'] = $total_time;
+ self::$metrics['peak_memory'] = $peak_memory;
+ self::$metrics['peak_memory_mb'] = $peak_memory_mb;
+ self::$metrics['timestamp'] = time();
+
+ // Calculate cache hit rate if object cache is available
+ if (function_exists('wp_cache_get_stats')) {
+ $cache_stats = wp_cache_get_stats();
+ if (isset($cache_stats['cache_hits']) && isset($cache_stats['cache_misses'])) {
+ $total_requests = $cache_stats['cache_hits'] + $cache_stats['cache_misses'];
+ if ($total_requests > 0) {
+ self::$metrics['cache_hit_rate'] = ($cache_stats['cache_hits'] / $total_requests) * 100;
+ }
+ }
+ }
+
+ // Check thresholds and send alerts
+ self::check_performance_thresholds();
+
+ // Store metrics for analysis
+ self::store_performance_metrics();
+
+ // Log performance summary for slow requests
+ if ($total_time > self::THRESHOLDS['page_load_time']) {
+ HVAC_Logger::warning(
+ "Slow page load: {$total_time}s, Memory: {$peak_memory_mb}MB, Queries: " . self::$metrics['query_count'],
+ 'Performance Monitor'
+ );
+ }
+ }
+
+ /**
+ * Check performance thresholds
+ */
+ private static function check_performance_thresholds() {
+ $alerts = [];
+
+ // Check page load time
+ if (self::$metrics['total_time'] > self::THRESHOLDS['page_load_time']) {
+ $alerts[] = [
+ 'type' => 'slow_page_load',
+ 'message' => 'Page load time exceeded threshold',
+ 'value' => self::$metrics['total_time'],
+ 'threshold' => self::THRESHOLDS['page_load_time']
+ ];
+ }
+
+ // Check memory usage
+ if (self::$metrics['peak_memory_mb'] > self::THRESHOLDS['memory_usage_mb']) {
+ $alerts[] = [
+ 'type' => 'high_memory_usage',
+ 'message' => 'Memory usage exceeded threshold',
+ 'value' => self::$metrics['peak_memory_mb'],
+ 'threshold' => self::THRESHOLDS['memory_usage_mb']
+ ];
+ }
+
+ // Check query count
+ if (self::$metrics['query_count'] > self::THRESHOLDS['db_query_count']) {
+ $alerts[] = [
+ 'type' => 'excessive_queries',
+ 'message' => 'Database query count exceeded threshold',
+ 'value' => self::$metrics['query_count'],
+ 'threshold' => self::THRESHOLDS['db_query_count']
+ ];
+ }
+
+ // Check slow queries
+ if (count(self::$metrics['slow_queries']) > 0) {
+ $alerts[] = [
+ 'type' => 'slow_queries',
+ 'message' => 'Slow queries detected',
+ 'value' => count(self::$metrics['slow_queries']),
+ 'threshold' => 0
+ ];
+ }
+
+ // Check cache hit rate
+ if (isset(self::$metrics['cache_hit_rate']) &&
+ self::$metrics['cache_hit_rate'] < self::THRESHOLDS['cache_hit_rate']) {
+ $alerts[] = [
+ 'type' => 'low_cache_hit_rate',
+ 'message' => 'Cache hit rate below threshold',
+ 'value' => self::$metrics['cache_hit_rate'],
+ 'threshold' => self::THRESHOLDS['cache_hit_rate']
+ ];
+ }
+
+ // Process alerts
+ if (!empty($alerts)) {
+ self::process_performance_alerts($alerts);
+ }
+ }
+
+ /**
+ * Process performance alerts
+ */
+ private static function process_performance_alerts($alerts) {
+ // Count recent alerts to avoid spam
+ $recent_alerts = self::get_recent_alerts(1800); // Last 30 minutes
+
+ if (count($recent_alerts) >= self::$alert_settings['alert_threshold']) {
+ return; // Cooldown period
+ }
+
+ // Store alerts
+ $stored_alerts = get_option('hvac_performance_alerts', []);
+ foreach ($alerts as $alert) {
+ $alert['timestamp'] = time();
+ $alert['request_uri'] = $_SERVER['REQUEST_URI'] ?? '';
+ $alert['user_agent'] = $_SERVER['HTTP_USER_AGENT'] ?? '';
+ $stored_alerts[] = $alert;
+ }
+
+ // Keep only last 1000 alerts
+ if (count($stored_alerts) > 1000) {
+ $stored_alerts = array_slice($stored_alerts, -1000);
+ }
+
+ update_option('hvac_performance_alerts', $stored_alerts);
+
+ // Send notifications
+ if (self::$alert_settings['email_alerts']) {
+ self::send_performance_alert_email($alerts);
+ }
+
+ // Check for critical issues
+ $critical_alerts = array_filter($alerts, function($alert) {
+ return $alert['type'] === 'slow_page_load' && $alert['value'] > 10 ||
+ $alert['type'] === 'high_memory_usage' && $alert['value'] > 256 ||
+ $alert['type'] === 'excessive_queries' && $alert['value'] > 500;
+ });
+
+ if (!empty($critical_alerts)) {
+ do_action('hvac_critical_performance_issue', $critical_alerts);
+ }
+ }
+
+ /**
+ * Get recent alerts
+ */
+ private static function get_recent_alerts($timeframe = 1800) {
+ $stored_alerts = get_option('hvac_performance_alerts', []);
+ $cutoff_time = time() - $timeframe;
+
+ return array_filter($stored_alerts, function($alert) use ($cutoff_time) {
+ return $alert['timestamp'] >= $cutoff_time;
+ });
+ }
+
+ /**
+ * Send performance alert email
+ */
+ private static function send_performance_alert_email($alerts) {
+ $admin_email = get_option('admin_email');
+ $site_name = get_bloginfo('name');
+
+ $subject = "[$site_name] Performance Alert";
+ $message = "Performance issues detected on $site_name:\n\n";
+
+ foreach ($alerts as $alert) {
+ $message .= "• {$alert['message']}\n";
+ $message .= " Value: {$alert['value']} (Threshold: {$alert['threshold']})\n\n";
+ }
+
+ $message .= "Request: " . ($_SERVER['REQUEST_URI'] ?? 'Unknown') . "\n";
+ $message .= "Time: " . date('Y-m-d H:i:s') . "\n";
+ $message .= "\nCheck the performance monitor for detailed analysis.";
+
+ wp_mail($admin_email, $subject, $message);
+ }
+
+ /**
+ * Store performance metrics
+ */
+ private static function store_performance_metrics() {
+ // Store in database for trend analysis
+ global $wpdb;
+
+ $metrics_data = [
+ 'timestamp' => time(),
+ 'page_load_time' => self::$metrics['total_time'],
+ 'peak_memory_mb' => self::$metrics['peak_memory_mb'],
+ 'query_count' => self::$metrics['query_count'],
+ 'slow_query_count' => count(self::$metrics['slow_queries']),
+ 'cache_hit_rate' => self::$metrics['cache_hit_rate'] ?? null,
+ 'request_uri' => $_SERVER['REQUEST_URI'] ?? '',
+ ];
+
+ // Store in options (simple approach - could use custom table for high-volume sites)
+ $stored_metrics = get_option('hvac_performance_metrics', []);
+ $stored_metrics[] = $metrics_data;
+
+ // Keep only last 1000 metrics
+ if (count($stored_metrics) > 1000) {
+ $stored_metrics = array_slice($stored_metrics, -1000);
+ }
+
+ update_option('hvac_performance_metrics', $stored_metrics);
+ }
+
+ /**
+ * Run performance benchmark
+ */
+ public static function run_performance_benchmark() {
+ $benchmark_results = [
+ 'timestamp' => time(),
+ 'database_benchmark' => self::benchmark_database(),
+ 'memory_benchmark' => self::benchmark_memory(),
+ 'cache_benchmark' => self::benchmark_cache(),
+ 'file_io_benchmark' => self::benchmark_file_io()
+ ];
+
+ // Store benchmark results
+ update_option('hvac_performance_benchmark', $benchmark_results);
+
+ HVAC_Logger::info(
+ 'Performance benchmark completed: ' . json_encode($benchmark_results),
+ 'Performance Monitor'
+ );
+
+ // Check if performance has degraded
+ $previous_benchmark = get_option('hvac_previous_benchmark', null);
+ if ($previous_benchmark) {
+ $degradation = self::check_performance_degradation($previous_benchmark, $benchmark_results);
+ if ($degradation) {
+ self::send_performance_alert_email([
+ [
+ 'type' => 'performance_degradation',
+ 'message' => 'Performance degradation detected',
+ 'details' => $degradation
+ ]
+ ]);
+ }
+ }
+
+ update_option('hvac_previous_benchmark', $benchmark_results);
+ }
+
+ /**
+ * Benchmark database performance
+ */
+ private static function benchmark_database() {
+ global $wpdb;
+
+ $start_time = microtime(true);
+
+ // Simple query benchmark
+ $wpdb->get_var("SELECT COUNT(*) FROM {$wpdb->posts}");
+ $simple_query_time = microtime(true) - $start_time;
+
+ // Complex query benchmark
+ $start_time = microtime(true);
+ $wpdb->get_results("
+ SELECT p.*, pm.meta_value
+ FROM {$wpdb->posts} p
+ LEFT JOIN {$wpdb->postmeta} pm ON p.ID = pm.post_id
+ WHERE p.post_type = 'post'
+ AND p.post_status = 'publish'
+ LIMIT 10
+ ");
+ $complex_query_time = microtime(true) - $start_time;
+
+ return [
+ 'simple_query_time' => round($simple_query_time, 4),
+ 'complex_query_time' => round($complex_query_time, 4)
+ ];
+ }
+
+ /**
+ * Benchmark memory performance
+ */
+ private static function benchmark_memory() {
+ $start_memory = memory_get_usage();
+
+ // Create test data
+ $test_data = [];
+ for ($i = 0; $i < 1000; $i++) {
+ $test_data[] = str_repeat('x', 1000);
+ }
+
+ $peak_memory = memory_get_usage();
+ $memory_used = $peak_memory - $start_memory;
+
+ unset($test_data);
+
+ return [
+ 'memory_used_mb' => round($memory_used / 1024 / 1024, 2),
+ 'peak_memory_mb' => round(memory_get_peak_usage() / 1024 / 1024, 2)
+ ];
+ }
+
+ /**
+ * Benchmark cache performance
+ */
+ private static function benchmark_cache() {
+ $iterations = 100;
+ $test_key = 'hvac_performance_test_' . time();
+ $test_data = str_repeat('x', 1000);
+
+ // Write benchmark
+ $start_time = microtime(true);
+ for ($i = 0; $i < $iterations; $i++) {
+ wp_cache_set($test_key . $i, $test_data, 'hvac_perf_test', 60);
+ }
+ $write_time = microtime(true) - $start_time;
+
+ // Read benchmark
+ $start_time = microtime(true);
+ for ($i = 0; $i < $iterations; $i++) {
+ wp_cache_get($test_key . $i, 'hvac_perf_test');
+ }
+ $read_time = microtime(true) - $start_time;
+
+ // Cleanup
+ for ($i = 0; $i < $iterations; $i++) {
+ wp_cache_delete($test_key . $i, 'hvac_perf_test');
+ }
+
+ return [
+ 'write_time' => round($write_time, 4),
+ 'read_time' => round($read_time, 4),
+ 'writes_per_second' => round($iterations / $write_time, 2),
+ 'reads_per_second' => round($iterations / $read_time, 2)
+ ];
+ }
+
+ /**
+ * Benchmark file I/O performance
+ */
+ private static function benchmark_file_io() {
+ $upload_dir = wp_upload_dir()['basedir'];
+ $test_file = $upload_dir . '/hvac_perf_test.txt';
+ $test_data = str_repeat('Performance test data. ', 1000);
+
+ // Write benchmark
+ $start_time = microtime(true);
+ file_put_contents($test_file, $test_data);
+ $write_time = microtime(true) - $start_time;
+
+ // Read benchmark
+ $start_time = microtime(true);
+ $read_data = file_get_contents($test_file);
+ $read_time = microtime(true) - $start_time;
+
+ // Cleanup
+ if (file_exists($test_file)) {
+ unlink($test_file);
+ }
+
+ return [
+ 'write_time' => round($write_time, 4),
+ 'read_time' => round($read_time, 4),
+ 'data_size_kb' => round(strlen($test_data) / 1024, 2)
+ ];
+ }
+
+ /**
+ * Check performance degradation
+ */
+ private static function check_performance_degradation($previous, $current) {
+ $degradation_threshold = 0.5; // 50% increase
+ $issues = [];
+
+ // Check database performance
+ $db_degradation = ($current['database_benchmark']['complex_query_time'] /
+ $previous['database_benchmark']['complex_query_time']) - 1;
+ if ($db_degradation > $degradation_threshold) {
+ $issues[] = "Database queries " . round($db_degradation * 100, 1) . "% slower";
+ }
+
+ // Check cache performance
+ $cache_degradation = ($current['cache_benchmark']['read_time'] /
+ $previous['cache_benchmark']['read_time']) - 1;
+ if ($cache_degradation > $degradation_threshold) {
+ $issues[] = "Cache reads " . round($cache_degradation * 100, 1) . "% slower";
+ }
+
+ return empty($issues) ? false : $issues;
+ }
+
+ /**
+ * Handle critical performance issues
+ */
+ public static function handle_critical_issue($alerts) {
+ // Log critical issue
+ HVAC_Logger::error(
+ 'Critical performance issue detected: ' . json_encode($alerts),
+ 'Performance Monitor'
+ );
+
+ // Send immediate alert
+ $admin_email = get_option('admin_email');
+ $site_name = get_bloginfo('name');
+
+ $subject = "[$site_name] CRITICAL Performance Issue";
+ $message = "CRITICAL performance issues detected:\n\n";
+
+ foreach ($alerts as $alert) {
+ $message .= "• {$alert['message']}: {$alert['value']}\n";
+ }
+
+ $message .= "\nImmediate attention required!";
+
+ wp_mail($admin_email, $subject, $message);
+
+ // Trigger error recovery if available
+ if (class_exists('HVAC_Error_Recovery')) {
+ do_action('hvac_operation_failed', 'performance', 'Critical performance degradation', $alerts);
+ }
+ }
+
+ /**
+ * Get performance statistics
+ */
+ public static function get_performance_stats() {
+ $metrics = get_option('hvac_performance_metrics', []);
+ $alerts = get_option('hvac_performance_alerts', []);
+ $benchmark = get_option('hvac_performance_benchmark', null);
+
+ if (empty($metrics)) {
+ return [
+ 'avg_page_load_time' => 0,
+ 'avg_memory_usage' => 0,
+ 'avg_query_count' => 0,
+ 'total_requests' => 0,
+ 'recent_alerts' => 0,
+ 'benchmark' => null
+ ];
+ }
+
+ $total_requests = count($metrics);
+ $recent_cutoff = time() - 86400; // Last 24 hours
+
+ // Calculate averages
+ $avg_page_load_time = array_sum(array_column($metrics, 'page_load_time')) / $total_requests;
+ $avg_memory_usage = array_sum(array_column($metrics, 'peak_memory_mb')) / $total_requests;
+ $avg_query_count = array_sum(array_column($metrics, 'query_count')) / $total_requests;
+
+ // Recent alerts
+ $recent_alerts = count(array_filter($alerts, function($alert) use ($recent_cutoff) {
+ return $alert['timestamp'] >= $recent_cutoff;
+ }));
+
+ return [
+ 'avg_page_load_time' => round($avg_page_load_time, 3),
+ 'avg_memory_usage' => round($avg_memory_usage, 2),
+ 'avg_query_count' => round($avg_query_count, 1),
+ 'total_requests' => $total_requests,
+ 'recent_alerts' => $recent_alerts,
+ 'benchmark' => $benchmark
+ ];
+ }
+
+ /**
+ * Add admin menu
+ */
+ public static function add_admin_menu() {
+ if (current_user_can('manage_options')) {
+ add_management_page(
+ 'HVAC Performance Monitor',
+ 'HVAC Performance',
+ 'manage_options',
+ 'hvac-performance-monitor',
+ [__CLASS__, 'admin_page']
+ );
+ }
+ }
+
+ /**
+ * Add admin bar stats
+ */
+ public static function add_admin_bar_stats($admin_bar) {
+ if (!current_user_can('manage_options') || !isset(self::$metrics['start_time'])) {
+ return;
+ }
+
+ $current_memory = round(memory_get_usage(true) / 1024 / 1024, 1);
+ $query_count = get_num_queries();
+
+ $admin_bar->add_node([
+ 'id' => 'hvac-performance',
+ 'title' => "HVAC: {$current_memory}MB | {$query_count}Q",
+ 'href' => admin_url('tools.php?page=hvac-performance-monitor')
+ ]);
+ }
+
+ /**
+ * Admin page
+ */
+ public static function admin_page() {
+ $stats = self::get_performance_stats();
+ $recent_alerts = array_slice(get_option('hvac_performance_alerts', []), -20, 20, true);
+ $current_metrics = self::$metrics;
+
+ ?>
+
+
HVAC Performance Monitor
+
+
+
+
+
Recent Performance Alerts
+
+
+
+ | Time |
+ Type |
+ Message |
+ Value |
+ Threshold |
+
+
+
+
+
+ | No recent performance alerts |
+
+
+
+
+ |
+ |
+ |
+ |
+ |
+
+
+
+
+
+
+
+
+
Performance Thresholds
+
The following thresholds trigger performance alerts:
+
+ - Slow Query Time: s
+ - Memory Usage: MB
+ - Page Load Time: s
+ - Database Query Count: queries
+ - Cache Hit Rate: %
+
+
+
+
+
+
+
+
HVAC Security Monitor
+
+
+
+
Security Overview
+
Total Events:
+
Recent Events (24h):
+
Blocked IPs:
+
+
+
+
Threat Distribution
+ $count): ?>
+
:
+
+
+
+
+
+
Recent Security Events
+
+
+
+ | Time |
+ Type |
+ Threat Level |
+ IP Address |
+ Details |
+
+
+
+
+
+ | No recent security events |
+
+
+
+
+ |
+ |
+ |
+ |
+
+
+ View Details
+
+
+ |
+
+
+
+
+
+
+
+
+
Blocked IP Addresses
+
+
+
+ | IP Address |
+ Reason |
+ Blocked At |
+ Expires |
+ Action |
+
+
+
+
+
+ | No blocked IPs |
+
+
+ $block_info): ?>
+
+ |
+ |
+ |
+ |
+
+
+ |
+
+
+
+
+
+
+
+
+
+
+